﻿using System;
using System.Drawing;
using System.ComponentModel;

namespace VB60
{
    #region 列挙体

    #region 描写系
    /// <summary>既定されたVBカラー(ARGB型)</summary> 
    public enum ColorConstants : int
    {
        /// <summary>黒</summary> 
        vbBlack = unchecked((int)0xff000000),
        /// <summary>青</summary> 
        vbBlue = unchecked((int)0xff0000ff),
        /// <summary>緑</summary> 
        vbGreen = unchecked((int)0xff00ff00),
        /// <summary>シアン</summary> 
        vbCyan = unchecked((int)0xff00ffff),
        /// <summary>赤</summary> 
        vbRed = unchecked((int)0xffff0000),
        /// <summary>マゼンタ</summary> 
        vbMagenta = unchecked((int)0xffff00ff),
        /// <summary>黄</summary> 
        vbYellow = unchecked((int)0xffffff00),
        /// <summary>白</summary> 
        vbWhite = unchecked((int)0xffffffff)
    }

    /// <summary>線のスタイル</summary> 
    public enum DrawStyleConstants
    {
        /// <summary>実線</summary> 
        vbSolid,
        /// <summary>ダッシュで構成される直線</summary> 
        vbDash,
        /// <summary>ドットで構成される直線</summary> 
        vbDot,
        /// <summary>ダッシュとドットの繰り返しパターンで構成される直線</summary> 
        vbDashDot,
        /// <summary>ダッシュと 2 つのドットの繰り返しパターンで構成される直線</summary> 
        vbDashDotDot
    }

    /// <summary>グラフィックススタイル</summary>
    [Microsoft.VisualBasic.CompilerServices.StandardModule()]
    public static class GraphicsStyle
    {
        /// <summary>直線を描くときのスタイル</summary>
        public enum LineStyle
        {
            /// <summary>直線</summary>
            Line,
            /// <summary>長方形</summary>
            Rectangle,
            /// <summary>塗りつぶしの長方形</summary>
            FillRectangle,
            /// <summary>長方形</summary>
            B = Rectangle,
            /// <summary>塗りつぶしの長方形</summary>
            BF = FillRectangle
        }

        /// <summary>曲線を描くときのスタイル</summary>
        public enum CurveStyle
        {
            /// <summary>曲線</summary>
            Curve,
            /// <summary>閉じた曲線(FillStyleでは交互塗りつぶし)</summary>
            CloseAlternateCurve,
            /// <summary>閉じた曲線(FillStyleでは全域塗りつぶし)</summary>
            CloseWindingCurve,
            /// <summary>交互塗りつぶしの曲線</summary>
            FillAlternateCurve,
            /// <summary>全域塗りつぶしの曲線</summary>
            FillWindingCurve
        }

        /// <summary>円を描くときのスタイル</summary>
        public enum CircleStyle
        {
            /// <summary>円弧</summary>
            Arc,
            /// <summary>扇型</summary>
            Pie,
            /// <summary>塗りつぶしの扇型</summary>
            FillPie
        }
    }

    /// <summary>塗りつぶしのスタイル</summary>
    public enum FillStyleConstants
    {
        /// <summary>塗りつぶし</summary> 
        vbFSSolid,
        /// <summary>透明</summary> 
        vbFSTransparent,
        /// <summary>横線</summary> 
        vbHorizontalLine,
        /// <summary>縦線</summary> 
        vbVerticalLine,
        /// <summary>斜線(左上-右下)</summary>
        vbUpwardDiagonal,
        /// <summary>斜線(左下-右上)</summary>
        vbDownwardDiagonal,
        /// <summary>クロス</summary>
        vbCross,
        /// <summary>網掛け</summary>
        vbDiagonalCross
    }

    /// <summary>ラスターオペレーション(画像合成の方法)</summary>
    public enum RasterOpConstants : int
    {
        /// <summary>ソースビットマップを、デスティネーションビットマップにコピー</summary>
        vbSrcCopy = 0xcc0020,
        /// <summary>デスティネーションビットマップと、ソースビットマップのピクセルを合成(OR)</summary>
        vbSrcPaint = 0xee0086,
        /// <summary>デスティネーションビットマップと、ソースビットマップのピクセルを合成(AND)</summary>
        vbSrcAnd = 0x8800c6,
        /// <summary>デスティネーションビットマップと、ソースビットマップのピクセルを合成(XOR)</summary>
        vbSrcInvert = 0x660046,
        /// <summary>デスティネーションビットマップを反転させた結果と、ソースビットマップのピクセルを合成(AND)</summary>
        vbSrcErase = 0x440328,
        /// <summary>ソースビットマップを反転させた結果を、デスティネーションビットマップにコピー</summary>
        vbNotSrcCopy = 0x330008,
        /// <summary>デスティネーションビットマップと、ソースビットマップのピクセルを合成した結果を反転(OR)</summary>
        vbNotSrcErase = 0x1100a6,
        /// <summary>パターンとソースビットマップを合成</summary>
        vbMergeCopy = 0xc000ca,
        /// <summary>反転したソースビットマップをデスティネーションビットマップに合成(OR)</summary>
        vbMergePaint = 0xbb0226,
        /// <summary>パターンをデスティネーションビットマップにコピー</summary>
        vbPatCopy = 0xf00021,
        /// <summary>デスティネーションビットマップをパターンと合成(OR)</summary>
        vbPatPaint = 0xfb0a09,
        /// <summary>反転したソースビットマップ/パターンをデスティネーションビットマップと合成(XOR)</summary>
        vbPatInvert = 0x5a0049,
        /// <summary>デスティネーションビットマップを反転</summary>
        vbDstInvert = 0x550009,
        /// <summary>黒で塗りつぶす</summary>
        vbBlackness = 0x42,
        /// <summary>白で塗りつぶす</summary>
        vbWhiteness = 0xff0062
    }
    #endregion

    #region その他
    /// <summary>仮想座標のモード</summary> 
    public enum ScaleModeConstants
    {
        /// <summary>Scale～の設定を使う</summary> 
        vbUser,
        /// <summary>Twip (1 インチ当たり 1,440 twip、1 センチ当たり 567 twip)</summary> 
        vbTwips,
        /// <summary>ポイント (1 論理インチ当たり 72 ポイント)</summary> 
        vbPoints,
        /// <summary>ピクセル (モニタまたはプリンタの解像度の最小単位)</summary> 
        vbPixels,
        /// <summary>文字 (水平方向 = 1 単位当たり 120 twip、垂直方向 = 1 単位当たり 240 twip)</summary> 
        vbCharacters,
        /// <summary>インチ(dpiに依存)</summary> 
        vbInches,
        /// <summary>ミリメートル (mm)</summary> 
        vbMillimeters,
        /// <summary>センチメートル (cm)</summary> 
        vbCentimeters,
        /// <summary>HiMetric (1 単位当たり0.01mm)</summary> 
        VbHimetric
    }

    //軸を示すネームスペース
    namespace AxialDirectionConstants
    {
        /// <summary>X軸の方向</summary>
        public enum XAxial
        {
            /// <summary>右</summary>
            Right,
            /// <summary>左</summary>
            Left
        }

        /// <summary>Y軸の方向</summary>
        public enum YAxial
        {
            /// <summary>下</summary>
            Bottom,
            /// <summary>上</summary>
            Top
        }
    }
    #endregion

    #endregion

    #region Informationモジュール
    /// <summary>VB6.0のInformationの一部のモジュールを提供します。</summary>
    /// <remarks>Information.QBColor(1) VB6.0のQBColor(1)と同等</remarks>
    [Microsoft.VisualBasic.CompilerServices.StandardModule()]
    public static class Information
    {
        /// <summary>ColorConstants型の色情報をColor構造体に変換する</summary>
        /// <param name="Obj">ColorConstants型の変換対象</param>
        /// <returns>変換後のColor構造体</returns>
        public static Color ToColor(this ColorConstants Obj)
        {
            int tmp = (int)Obj;
            return Color.FromArgb((byte)(tmp >> 24), (byte)(tmp >> 16), (byte)(tmp >> 8), (byte)tmp);
        }

        /// <summary>赤・緑・青それぞれの値から色を作る(ARGB形式)</summary>
        /// <param name="Red">赤の強さ(0～255の範囲)</param>
        /// <param name="Green">緑の強さ(0～255の範囲)</param>
        /// <param name="Blue">青の強さ(0～255の範囲)</param>
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>Information.RGB(100,100,100) VB6.0のRGB(100,100,100)と同等</para>
        /// </example></remarks>
        public static ColorConstants RGB(byte Red, byte Green, byte Blue)
        {
            return (ColorConstants)((255 << 24) | (Red << 16) | (Green << 8) | Blue);
        }

        /// <summary>アルファ・赤・緑・青それぞれの値から色を作る(ARGB形式)</summary>
        /// <param name="Alpha">不透明度の強さ(0～255の範囲)</param>
        /// <param name="Red">赤の強さ(0～255の範囲)</param>
        /// <param name="Green">緑の強さ(0～255の範囲)</param>
        /// <param name="Blue">青の強さ(0～255の範囲)</param>
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>Information.ARGB(100,100,100,100) Color.FromArgb(100, 100, 100, 100).ToArgb()と同等(ただしARGB形式で扱う)</para>
        /// </example></remarks>
        public static ColorConstants ARGB(byte Alpha, byte Red, byte Green, byte Blue)
        {
            return (ColorConstants)((Alpha << 24) | (Red << 16) | (Green << 8) | Blue);
        }

        /// <summary>アルファ・既定色そから不透明度を設定しなおして色を作る(ARGB形式)</summary>
        /// <param name="Alpha">不透明度の強さ(0～255の範囲)</param>
        /// <param name="BaseColor">ベースとなる既定色</param>
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>Information.ARGB(100,ColorConstants.Black) Color.FromArgb(100, Color.Black).ToArgb()と同等(ただしARGB形式で扱う)</para>
        /// </example></remarks>
        public static ColorConstants ARGB(byte Alpha, ColorConstants BaseColor)
        {
            return (ColorConstants)((Alpha << 24) | (0xffffff & (int)BaseColor));
        }

        /// <summary>あらかじめ決められた色を取得する(ARGB形式)</summary> 
        /// <param name="VBColor">VB6.0の識別の整数(0～15) それ以外の範囲は透明色を返す</param> 
        /// <returns>取得した色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks>
        /// <example>メソッドの使用例 
        /// <para>Information.QBColor(0) VB6.0のQBColor(0)と同等</para> 
        /// </example></remarks>
        public static ColorConstants QBColor(int VBColor)
        {
            long ARGB = 0;

            switch (VBColor)
            {
                case 0:
                    ARGB = 0xff000000;
                    break;

                case 1:
                    ARGB = 0xff000080;
                    break;

                case 2:
                    ARGB = 0xff008000;
                    break;

                case 3:
                    ARGB = 0xff008080;
                    break;

                case 4:
                    ARGB = 0xff800000;
                    break;

                case 5:
                    ARGB = 0xff800080;
                    break;

                case 6:
                    ARGB = 0xff808000;
                    break;

                case 7:
                    ARGB = 0xffc0c0c0;
                    break;

                case 8:
                    ARGB = 0xff808080;
                    break;

                case 9:
                    ARGB = 0xff0000ff;
                    break;

                case 10:
                    ARGB = 0xff00ff00;
                    break;

                case 11:
                    ARGB = 0xff00ffff;
                    break;

                case 12:
                    ARGB = 0xffff0000;
                    break;

                case 13:
                    ARGB = 0xffff00ff;
                    break;

                case 14:
                    ARGB = 0xffffff00;
                    break;

                case 15:
                    ARGB = 0xffffffff;
                    break;

                default:
                    ARGB = 0x00000000;
                    break;
            }

            return (ColorConstants)ARGB;
        }
    }
    #endregion

    #region PictureBoxクラス
    /// <summary>VB6.0のPictureBoxとほぼ同等なPictureBox</summary>
    /// <remarks>
    /// クラスの利用方法(VB.NET) C#での引数途中省略は引数にnullを指定する PictureBox.Circle(0,0,1,null,null,null,2);
    /// <para>宣言と初期化　　　　：Dim A As VB60.PictureBox = New VB60.PictureBox()</para>
    /// <para>座標軸の方向設定　　：A.YAxialDirection = AxialDirectionConstants.YAxial.Top等</para>
    /// <para>仮想座標の設定　　　：A.Init_Scale(-1,1,2,2) →数学座標の-1～1の幅高さそれぞれ2の仮想座標の設定</para>
    /// <para>使う前の最後の初期化：A.Starting_Init()</para>
    /// <para>実際に使用する　　　：A.Line(X1,Y1,X2,Y2)等</para>
    /// <para>外部から操作する　　：A.Interrupt()→外部操作→A.Interrupt()</para>
    /// </remarks>
    [ToolboxBitmap(typeof(PictureBox), "PictureBox.bmp"), ToolboxItem(true), TypeConverter(typeof(ExpandableObjectConverter)), Description("VB6.0のPictureBoxとほぼ同等なPictureBoxを提供します。")]
    public class PictureBox : System.Windows.Forms.PictureBox
    {
        #region フィールド
        private bool StartEnabledFlag;
        private float SW;
        private float SH;
        private float ST;
        private float SL;
        private ScaleModeConstants SM;
        private float NowX;
        private float NowY;
        private System.Drawing.Drawing2D.CompositingMode DrawCMode;
        private System.Drawing.Drawing2D.SmoothingMode DrawSMode;
        private FillStyleConstants FStyle;
        private bool ARedraw;
        private AxialDirectionConstants.XAxial XAD;
        private AxialDirectionConstants.YAxial YAD;
        private PictureBoxUnitConvert Converter;
        /// <summary>描画対象=基底クラスのImageに代入</summary>
        private Bitmap ScaleImage;
        /// <summary>描画対象のGraphicsオブジェクト</summary>
        private System.Drawing.Graphics TargetGraphics;
        /// <summary>描画時に使うPen</summary>
        private System.Drawing.Pen DrawPen;
        /// <summary>塗りつぶし時に使うブラシ</summary>
        private System.Drawing.Drawing2D.HatchBrush FillBrush;
        #endregion

        #region プロパティ

        #region 仮想座標系
        /// <summary>仮想座標の幅(マイナスの値の場合はX軸の方向がLeftになる)</summary>
        [Category("仮想座標"), DefaultValue(100.0f), RefreshProperties(RefreshProperties.Repaint), Description("仮想座標の幅を入力・取得します。(マイナスの値の場合はX軸の方向がLeftになる)")]
        public float ScaleWidth
        {
            get { return this.SW; }

            set
            {
                this.SW = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標の高さ(マイナスの値の場合はY軸の方向がTopになる)</summary>
        [Category("仮想座標"), DefaultValue(100.0f), RefreshProperties(RefreshProperties.Repaint), Description("仮想座標の高さの値を入力・取得します。(マイナスの値の場合はY軸の方向がTopになる)")]
        public float ScaleHeight
        {
            get { return this.SH; }

            set
            {
                this.SH = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標の上端の値</summary>
        [Category("仮想座標"), DefaultValue(0.0f), RefreshProperties(RefreshProperties.Repaint), Description("仮想座標の上端の値を入力・取得します。")]
        public float ScaleTop
        {
            get { return this.ST; }

            set
            {
                this.ST = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標の左端の値</summary>
        [Category("仮想座標"), DefaultValue(0.0f), RefreshProperties(RefreshProperties.Repaint), Description("仮想座標の左端の値を入力・取得します。")]
        public float ScaleLeft
        {
            get { return this.SL; }

            set
            {
                this.SL = value;
                Init_CurrentValue();
            }
        }

        /// <summary>X軸の方向(Xのプラス方向)</summary>
        [Category("仮想座標"), DefaultValue(AxialDirectionConstants.XAxial.Right), Description("仮想座標のX軸の方向(プラス側)をAxialDirectionConstants.XAxial形式で入力・取得します。")]
        public AxialDirectionConstants.XAxial XAxialDirection
        {
            get { return this.XAD; }

            set
            {
                this.XAD = value;
                Init_CurrentValue();
            }
        }

        /// <summary>Y軸の方向(Yのプラス方向)</summary>
        [Category("仮想座標"), DefaultValue(AxialDirectionConstants.YAxial.Bottom), Description("仮想座標のY軸の方向(プラス側)をAxialDirectionConstants.YAxial形式で入力・取得します。")]
        public AxialDirectionConstants.YAxial YAxialDirection
        {
            get { return this.YAD; }

            set
            {
                this.YAD = value;
                Init_CurrentValue();
            }
        }

        /// <summary>仮想座標のモード</summary>
        [Category("仮想座標"), DefaultValue(ScaleModeConstants.vbPixels), RefreshProperties(RefreshProperties.Repaint), Description("仮想座標のモードをScaleModeConstants形式で入力・取得します。")]
        public ScaleModeConstants ScaleMode
        {
            get { return this.SM; }

            set
            {
                this.SM = value;
                Init_CurrentValue();
            }
        }
        #endregion

        #region 描写系
        /// <summary>描写位置X</summary>
        [Category("VB描写"), RefreshProperties(RefreshProperties.Repaint), Description("次の描写で書き始める座標位置Xを入力・取得します。")]
        public float CurrentX
        {
            get { return this.NowX; }

            set { this.NowX = value; }
        }

        /// <summary>描写位置Y</summary>
        [Category("VB描写"), RefreshProperties(RefreshProperties.Repaint), Description("次の描写で書き始める座標位置Yを入力・取得します。")]
        public float CurrentY
        {
            get { return this.NowY; }

            set { this.NowY = value; }
        }

        /// <summary>直線や円を描く時の線の色(ColorConstants形式(ARGB形式))</summary>
        [Category("VB描写"), DefaultValue(ColorConstants.vbBlack), Description("直線や円を描く時の線の色をColorConstants形式(ARGB形式)で入力・取得します。")]
        public ColorConstants DrawColor
        {
            get { return (ColorConstants)this.DrawPen.Color.ToArgb(); }

            set { this.DrawPen.Color = Color.FromArgb((int)value); }
        }

        /// <summary>直線や円を描く時の線の太さ(0.0以下は代入不可)</summary>
        [Category("VB描写"), DefaultValue(1.0f), Description("直線や円を描く時の線の太さ(0.0以下は代入不可)を入力・取得します。")]
        public float DrawWidth
        {
            get { return this.DrawPen.Width; }

            set
            {
                if (value <= 0.0f)
                    return;

                this.DrawPen.Width = value;
            }
        }

        /// <summary>直線や円を描く時の線の上書き手法</summary>
        [Category("VB描写"), DefaultValue(System.Drawing.Drawing2D.CompositingMode.SourceOver), Description("直線や円を描く時の上書き手法をSystem.Drawing.Drawing2D.CompositingMode形式で入力・取得します。")]
        public System.Drawing.Drawing2D.CompositingMode DrawCompositingMode
        {
            get { return this.DrawCMode; }

            set
            {
                this.DrawCMode = value;

                if (this.TargetGraphics != null)
                    this.TargetGraphics.CompositingMode = value;
            }
        }

        /// <summary>直線や円を描く時の線の品質</summary>
        [Category("VB描写"), DefaultValue(System.Drawing.Drawing2D.SmoothingMode.Default), Description("直線や円を描く時の品質をSystem.Drawing.Drawing2D.SmoothingMode形式で入力・取得します。")]
        public System.Drawing.Drawing2D.SmoothingMode DrawSmoothingMode
        {
            get { return this.DrawSMode; }

            set
            {
                this.DrawSMode = value;

                if (this.TargetGraphics != null)
                    this.TargetGraphics.SmoothingMode = value;
            }
        }

        /// <summary>直線や円弧・扇を描く時の破線時の形</summary> 
        [Category("VB描写"), DefaultValue(System.Drawing.Drawing2D.DashCap.Flat), Description("直線や円弧・扇を描く時の線の破線時の形をSystem.Drawing.Drawing2D.DashCap形式で入力・取得します。")]
        public System.Drawing.Drawing2D.DashCap DrawDashCap
        {
            get { return this.DrawPen.DashCap; }

            set { this.DrawPen.DashCap = value; }
        }

        /// <summary>直線や円弧・扇を描く時の線の始点の形</summary> 
        [Category("VB描写"), DefaultValue(System.Drawing.Drawing2D.LineCap.Flat), Description("直線や円弧・扇を描く時の線の始点の形をSystem.Drawing.Drawing2D.LineCap形式で入力・取得します。")]
        public System.Drawing.Drawing2D.LineCap DrawStartCap
        {
            get { return this.DrawPen.StartCap; }

            set { this.DrawPen.StartCap = value; }
        }

        /// <summary>直線や円弧・扇を描く時の線の終点の形</summary> 
        [Category("VB描写"), DefaultValue(System.Drawing.Drawing2D.LineCap.Flat), Description("直線や円弧・扇を描く時の線の終点の形をSystem.Drawing.Drawing2D.LineCap形式で入力・取得します。")]
        public System.Drawing.Drawing2D.LineCap DrawEndCap
        {
            get { return this.DrawPen.EndCap; }

            set { this.DrawPen.EndCap = value; }
        }

        /// <summary>直線や円を描く時の線のスタイル int型でしてしても良い(0～4)</summary>
        [Category("VB描写"), DefaultValue(DrawStyleConstants.vbSolid), Description("直線や円を描く時の線のスタイルをDrawStyleConstants形式またはint型(0～4)で入力・取得します。")]
        public DrawStyleConstants DrawStyle
        {
            get
            {
                DrawStyleConstants value = default(DrawStyleConstants);

                switch (this.DrawPen.DashStyle)
                {
                    case System.Drawing.Drawing2D.DashStyle.Solid:
                        value = DrawStyleConstants.vbSolid;
                        break;

                    case System.Drawing.Drawing2D.DashStyle.Dash:
                        value = DrawStyleConstants.vbDash;
                        break;

                    case System.Drawing.Drawing2D.DashStyle.Dot:
                        value = DrawStyleConstants.vbDot;
                        break;

                    case System.Drawing.Drawing2D.DashStyle.DashDot:
                        value = DrawStyleConstants.vbDashDot;
                        break;

                    case System.Drawing.Drawing2D.DashStyle.DashDotDot:
                        value = DrawStyleConstants.vbDashDotDot;
                        break;
                }

                return value;
            }

            set
            {
                switch (value)
                {
                    case DrawStyleConstants.vbSolid:
                        this.DrawPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Solid;
                        break;

                    case DrawStyleConstants.vbDash:
                        this.DrawPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dash;
                        break;

                    case DrawStyleConstants.vbDot:
                        this.DrawPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
                        break;

                    case DrawStyleConstants.vbDashDot:
                        this.DrawPen.DashStyle = System.Drawing.Drawing2D.DashStyle.DashDot;
                        break;

                    case DrawStyleConstants.vbDashDotDot:
                        this.DrawPen.DashStyle = System.Drawing.Drawing2D.DashStyle.DashDotDot;
                        break;

                    default:
                        break;
                }
            }
        }

        /// <summary>直線や円を描く時の塗りつぶしの色(ColorConstants形式(ARGB形式))</summary>
        [Category("VB描写"), DefaultValue(ColorConstants.vbBlack), Description("直線(長方形モード時)や円(扇形モード時)を描く時の塗りつぶしの色をColorConstants形式(ARGB形式)で入力・取得します。")]
        public ColorConstants FillColor
        {
            get { return (ColorConstants)this.FillBrush.ForegroundColor.ToArgb(); }

            set
            {
                System.Drawing.Drawing2D.HatchBrush tmp = (System.Drawing.Drawing2D.HatchBrush)this.FillBrush.Clone();
                this.FillBrush.Dispose();
                this.FillBrush = new System.Drawing.Drawing2D.HatchBrush(tmp.HatchStyle, System.Drawing.Color.FromArgb((int)value), tmp.BackgroundColor);
                tmp.Dispose();
            }
        }

        /// <summary>直線や円を描く時の塗りつぶしのスタイル int型でしてしても良い(0～7)</summary>
        [Category("VB描写"), DefaultValue(FillStyleConstants.vbFSTransparent), Description("直線や円を描く時の塗りつぶしのスタイルをFillStyleConstants形式またはint型(0～7)で入力・取得します。")]
        public FillStyleConstants FillStyle
        {
            get { return this.FStyle; }

            set
            {
                System.Drawing.Drawing2D.HatchStyle tmp = System.Drawing.Drawing2D.HatchStyle.ZigZag;

                switch (value)
                {
                    case FillStyleConstants.vbFSSolid:
                        break;

                    case FillStyleConstants.vbFSTransparent:
                        break;

                    case FillStyleConstants.vbHorizontalLine:
                        tmp = System.Drawing.Drawing2D.HatchStyle.Horizontal;
                        break;

                    case FillStyleConstants.vbVerticalLine:
                        tmp = System.Drawing.Drawing2D.HatchStyle.Vertical;
                        break;

                    case FillStyleConstants.vbUpwardDiagonal:
                        tmp = System.Drawing.Drawing2D.HatchStyle.ForwardDiagonal;
                        break;

                    case FillStyleConstants.vbDownwardDiagonal:
                        tmp = System.Drawing.Drawing2D.HatchStyle.BackwardDiagonal;
                        break;

                    case FillStyleConstants.vbCross:
                        tmp = System.Drawing.Drawing2D.HatchStyle.Cross;
                        break;

                    case FillStyleConstants.vbDiagonalCross:
                        tmp = System.Drawing.Drawing2D.HatchStyle.DiagonalCross;
                        break;

                    default:
                        return;
                }

                if (tmp != System.Drawing.Drawing2D.HatchStyle.ZigZag)
                {
                    System.Drawing.Drawing2D.HatchBrush htmp = (System.Drawing.Drawing2D.HatchBrush)this.FillBrush.Clone();
                    this.FillBrush.Dispose();
                    this.FillBrush = new System.Drawing.Drawing2D.HatchBrush(tmp, htmp.ForegroundColor, htmp.BackgroundColor);
                    htmp.Dispose();
                }

                this.FStyle = value;
            }
        }

        /// <summary>文字を書くときのフォント</summary>
        [Category("VB描写"), RefreshProperties(RefreshProperties.None), Description("文字を書くときのフォントを入力・取得します。")]
        public System.Drawing.Font DrawFont
        {
            get { return base.Font; }

            set { base.Font = value; }
        }
        #endregion

        #region その他
        /// <summary>自動的に再描写するかどうか</summary>
        [Category("Behavior"), DefaultValue(false), Description("自動的に再描写するかどうかを入力・取得します。")]
        public bool AutoRedraw
        {
            get { return this.ARedraw; }

            set { this.ARedraw = value; }
        }

        /// <summary>自動的にイメージをリサイズするかどうか(注：StartingInitの時点での大きさを基にしているので画像が崩れることがある)</summary> 
        [Category("Behavior"), DefaultValue(false), Description("自動的にイメージをリサイズするかどうかを入力・取得します。(TrueにするとSizeModeがStretchImageになります。)")]
        public bool AutoResize
        {
            get { return base.SizeMode != System.Windows.Forms.PictureBoxSizeMode.Normal; }

            set { base.SizeMode = (value == true ? System.Windows.Forms.PictureBoxSizeMode.StretchImage : System.Windows.Forms.PictureBoxSizeMode.Normal); }
        }

        /// <summary>現在の描画画像を取得(コピー)、もし生成されていなかったらNothing(null)を返す 代入は前のイメージが破棄される</summary>
        [Browsable(false)]
        public new System.Drawing.Image Image
        {
            get { return (System.Drawing.Image)(this.ScaleImage == null ? null : this.ScaleImage.Clone()); }

            set
            {
                if (this.TargetGraphics != null)
                    this.TargetGraphics.Dispose();

                if (this.ScaleImage != null)
                    this.ScaleImage.Dispose();

                this.ScaleImage = (System.Drawing.Bitmap)value;
                base.Image = this.ScaleImage;

                if ((this.ScaleImage != null) && (this.TargetGraphics != null))
                    this.TargetGraphics = GetTargetGraphics();

                TryAutoRedraw();
            }
        }

        /// <summary>既にStarting_Initが行われており、すぐ使える状態かどうか(Interruptでの中断では変化しない)</summary>
        [Browsable(false)]
        public bool StartEnabled
        {
            get { return this.StartEnabledFlag; }

            private set { this.StartEnabledFlag = value; }
        }
        #endregion

        #endregion

        #region 初期化・設定メソッド
        /// <summary>コンストラクタ(基底クラスのPictureBoxも生成)</summary> 
        public PictureBox()
            : base()
        {
            this.StartEnabledFlag = false;
            this.TargetGraphics = null;
            this.ScaleImage = null;

            this.DrawPen = new Pen(Color.Black, 1.0f);
            this.DrawPen.DashCap = System.Drawing.Drawing2D.DashCap.Flat;
            this.DrawPen.StartCap = System.Drawing.Drawing2D.LineCap.Flat;
            this.DrawPen.EndCap = System.Drawing.Drawing2D.LineCap.Flat;
            this.FillBrush = new System.Drawing.Drawing2D.HatchBrush(System.Drawing.Drawing2D.HatchStyle.Horizontal, Color.Black, base.BackColor);
            this.FStyle = FillStyleConstants.vbFSTransparent;
            this.DrawCMode = System.Drawing.Drawing2D.CompositingMode.SourceOver;
            this.DrawSMode = System.Drawing.Drawing2D.SmoothingMode.Default;

            this.SW = 100.0f;
            this.SL = 0.0f;
            this.SH = 100.0f;
            this.ST = 0.0f;
            this.SM = ScaleModeConstants.vbPixels;
            this.XAD = AxialDirectionConstants.XAxial.Right;
            this.YAD = AxialDirectionConstants.YAxial.Bottom;

            this.AutoRedraw = false;
            this.AutoResize = false;

            Init_CurrentValue();
        }

        /// <summary>リソースの開放</summary> 
        protected override void Dispose(bool disposing)
        {
            if (this.TargetGraphics != null)
                this.TargetGraphics.Dispose();

            if (this.ScaleImage != null)
                this.ScaleImage.Dispose();

            this.DrawPen.Dispose();
            this.FillBrush.Dispose();
            base.Dispose(disposing);
        }

        /// <summary>Scale～の設定(vbUserに自動設定、Current～も初期化)</summary> 
        /// <param name="ScaleWidth">仮想座標の幅(マイナスの値の場合はX軸の方向がLeftになる)</param> 
        /// <param name="ScaleHeight">仮想座標の高さ(マイナスの値の場合はY軸の方向がTopになる)</param> 
        /// <param name="ScaleLeft">仮想座標の左端の値</param> 
        /// <param name="ScaleTop">仮想座標の上端の値</param> 
        public void Init_Scale(float ScaleLeft, float ScaleTop, float ScaleWidth, float ScaleHeight)
        {
            this.ScaleWidth = ScaleWidth;
            this.ScaleLeft = ScaleLeft;
            this.ScaleHeight = ScaleHeight;
            this.ScaleTop = ScaleTop;
            this.ScaleMode = ScaleModeConstants.vbUser;

            Init_CurrentValue();
        }

        /// <summary>実際に使うための準備メソッド 描いてあるイメージなどは全て破棄する</summary>
        public void Starting_Init()
        {
            if (base.Width == 0 || base.Height == 0)
            {
                System.Windows.Forms.MessageBox.Show("Starting_Init : PictureBoxの幅及び高さが0の時にはこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (this.TargetGraphics != null)
                this.TargetGraphics.Dispose();

            if (this.ScaleImage != null)
                this.ScaleImage.Dispose();

            this.ScaleImage = new Bitmap(base.Width, base.Height);
            base.Image = this.ScaleImage;

            this.TargetGraphics = GetTargetGraphics();
            this.StartEnabled = true;
            this.Converter = new PictureBoxUnitConvert(this);
        }

        /// <summary>内部の動作を一時停止・再稼働させる(ResizeはそのままRedrawは停止、Graphicsオブジェクトを破棄・再生成)</summary>
        public void Interrupt()
        {
            if (!this.StartEnabled)
            {
                System.Windows.Forms.MessageBox.Show("Interrupt : Starting_Initしてない状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            //再開
            if (this.TargetGraphics == null)
            {
                this.TargetGraphics = GetTargetGraphics();
                TryAutoRedraw();
            }

            //中断
            else
            {
                this.TargetGraphics.Dispose();
                this.TargetGraphics = null;
            }
        }

        /// <summary>外部アクセスの場合に使うメソッド Graphicsオブジェクトを作成して返す</summary>
        /// <param name="DirectAccess">直接アクセスするかどうか 直接アクセスでImageに直接描写する 省略可 その場合Falseになる</param>
        /// <returns>作られたGraphicsオブジェクト</returns>
        /// <remarks>
        /// <example>メソッドの使用例 
        /// <para>注意：これを直接アクセスで使う場合Interruptで一時停止させる必要がある。通常アクセスは基底クラスのCreateGraphicsと同じである。</para>
        /// <para>外部アクセス時にはAutoRedrawは動作しないので内部動作を再開した時のRedrawに任せるか、明示的にPictureBox.Redraw()を呼び出す。</para>
        /// <para>PictureBox.Interrupt()</para>
        /// <para>Dim g As Graphics = PictureBox.CreateGraphics(True)</para>
        /// <para>g.DrawRectangle(Pens.Black,PictureBox.X(-0.5), _</para>
        /// <para>PictureBox.Y(0.5),PictureBox.VX(1),PictureBox.VY(1))</para>
        /// <para>g.Dispose()</para>
        /// <para>PictureBox.Interrupt()：(この時点でAutoRedrawが再開される。)</para>
        /// </example></remarks>
        public System.Drawing.Graphics CreateGraphics(bool DirectAccess = false)
        {
            //直接アクセス
            if (DirectAccess)
            {
                if (this.TargetGraphics != null)
                {
                    System.Windows.Forms.MessageBox.Show("CreateGraphics : Interruptで中断していない状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                    return null;
                }

                return Graphics.FromImage(this.ScaleImage);
            }

            //既定クラスアクセス
            else
                return base.CreateGraphics();
        }

        /// <summary>単位変換メソッドを提供します。</summary>
        public PictureBoxUnitConvert Cnv()
        {
            if (!this.StartEnabled)
            {
                System.Windows.Forms.MessageBox.Show("Cnv : Starting_Initしてない状態ではこのメソッドにアクセスできません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return null;
            }

            return this.Converter;
        }

        /// <summary>Current～の値の初期化メソッド</summary>
        private void Init_CurrentValue()
        {
            //幅がマイナスの場合反転させてX軸方向をLeftにする
            if (this.ScaleWidth < 0)
            {
                this.SW = -this.SW;
                this.XAxialDirection = AxialDirectionConstants.XAxial.Left;
            }

            //高さがマイナスの場合反転させてY軸方向をTopにする
            if (this.ScaleHeight < 0)
            {
                this.SH = -this.SH;
                this.YAxialDirection = AxialDirectionConstants.YAxial.Top;
            }

            if (this.ScaleMode == ScaleModeConstants.vbUser)
            {
                this.CurrentX = this.ScaleLeft;
                this.CurrentY = this.ScaleTop;
            }

            else
            {
                this.CurrentX = (this.XAxialDirection == AxialDirectionConstants.XAxial.Right) ? 0 : (this.ScaleImage == null ? base.Width : this.ScaleImage.Width);
                this.CurrentY = (this.YAxialDirection == AxialDirectionConstants.YAxial.Bottom) ? 0 : (this.ScaleImage == null ? base.Height : this.ScaleImage.Height);
            }
        }

        /// <summary>イメージに対して描画するGraphicsオブジェクトを取得する</summary>
        /// <returns>Graphicsオブジェクト</returns>
        private Graphics GetTargetGraphics()
        {
            Graphics g = Graphics.FromImage(this.ScaleImage);
            g.CompositingMode = this.DrawCompositingMode;
            g.SmoothingMode = this.DrawSmoothingMode;
            return g;
        }
        #endregion

        #region Redrawメソッド
        /// <summary>AutoRedrawに従って非同期で再描画する</summary> 
        private void TryAutoRedraw()
        {
            if (!this.AutoRedraw)
                return;

            base.Invalidate();
        }

        /// <summary>再描写する(基底クラスのCreateGraphicsからアクセスして再描画する場合は非同期で行うと動作がおかしくなる)</summary> 
        /// <param name="NonSynchronize">非同期で再描画するかどうか 省略化 その場合Trueになる</param>
        public void Redraw(bool NonSynchronize = true)
        {
            if (NonSynchronize)
                base.Invalidate();

            else
                base.Refresh();
        }
        #endregion

        #region 単位変換メソッド

        #region 通常変換
        /// <summary>GetX() : ScaleModeに従ってある単位での座標Xをピクセル単位での座標Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetX()</para></remarks>
        public float X(float Value)
        {
            return GetX(Value);
        }

        /// <summary>GetY() : ScaleModeに従ってある単位での座標Yをピクセル単位での座標Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetY()</para></remarks>
        public float Y(float Value)
        {
            return GetY(Value);
        }

        /// <summary>GetArrayX() : ScaleModeに従ってある単位での座標配列Xをピクセル単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayX()</para></remarks>
        public float[] AX(float[] Value)
        {
            return GetArrayX(Value);
        }

        /// <summary>GetArrayY() : ScaleModeに従ってある単位での座標配列Yをピクセル単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayY()</para></remarks>
        public float[] AY(float[] Value)
        {
            return GetArrayY(Value);
        }

        /// <summary>GetValueX() : ScaleModeに従ってある単位の値Xをピクセル単位の値Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueX()</para></remarks>
        public float VX(float Value)
        {
            return GetValueX(Value);
        }

        /// <summary>GetValueY() : ScaleModeに従ってある単位の値Yをピクセル単位の値Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueY()</para></remarks>
        public float VY(float Value)
        {
            return GetValueY(Value);
        }

        /// <summary>GetValueArrayX() : ScaleModeに従ってある単位の値配列Xをピクセル単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayX()</para></remarks>
        public float[] VAX(float[] Value)
        {
            return GetValueArrayX(Value);
        }

        /// <summary>GetValueArrayY() : ScaleModeに従ってある単位の値配列Yをピクセル単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayY()</para></remarks>
        public float[] VAY(float[] Value)
        {
            return GetValueArrayY(Value);
        }

        /// <summary>GetPoint() : ScaleModeに従ってある単位の座標点をピクセル単位の座標点に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点</param>
        /// <returns>ピクセル単位の座標点</returns>
        /// <remarks>内部アクセス名<para>GetPoint()</para></remarks>
        public PointF P(PointF Value)
        {
            return GetPoint(Value);
        }

        /// <summary>GetArrayPoint() : ScaleModeに従ってある単位の座標点配列をピクセル単位の座標点配列に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点配列</param>
        /// <returns>ピクセル単位の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetArrayPoint()</para></remarks>
        public PointF[] AP(PointF[] Value)
        {
            return GetArrayPoint(Value);
        }

        /// <summary>GetValueSize() : ScaleModeに従ってある単位のサイズをピクセル単位のサイズに変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ</param> 
        /// <returns>ピクセル単位のサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetValueSize()</para></remarks>
        public SizeF VS(SizeF Value)
        {
            return GetValueSize(Value);
        }

        /// <summary>GetValueArraySize() : ScaleModeに従ってある単位のサイズ配列をピクセル単位のサイズ配列に変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ配列</param> 
        /// <returns>ピクセル単位のサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArraySize()</para></remarks>
        public SizeF[] VAS(SizeF[] Value)
        {
            return GetValueArraySize(Value);
        }
        #endregion

        #region 逆変換
        /// <summary>GetReverseX() : ピクセル単位での座標XをScaleModeに従ってある単位での座標Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseX()</para></remarks>
        public float RX(float Value)
        {
            return GetReverseX(Value);
        }

        /// <summary>GetReverseY() : ピクセル単位での座標YをScaleModeに従ってある単位での座標Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseY()</para></remarks>
        public float RY(float Value)
        {
            return GetReverseY(Value);
        }

        /// <summary>GetReverseArrayX() : ピクセル単位での座標配列XをScaleModeに従ってある単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayX()</para></remarks>
        public float[] RAX(float[] Value)
        {
            return GetReverseArrayX(Value);
        }

        /// <summary>GetReverseArrayY() : ピクセル単位での座標配列YをScaleModeに従ってある単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayY()</para></remarks>
        public float[] RAY(float[] Value)
        {
            return GetReverseArrayY(Value);
        }

        /// <summary>GetReverseValueX() : ピクセル単位の値XをScaleModeに従ってある単位の値Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueX()</para></remarks>
        public float RVX(float Value)
        {
            return GetReverseValueX(Value);
        }

        /// <summary>GetReverseValueY() : ピクセル単位の値YをScaleModeに従ってある単位の値Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueY()</para></remarks>
        public float RVY(float Value)
        {
            return GetReverseValueY(Value);
        }

        /// <summary>GetReverseValueArrayX() : ピクセル単位の値配列XをScaleModeに従ってある単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayX()</para></remarks>
        public float[] RVAX(float[] Value)
        {
            return GetReverseValueArrayX(Value);
        }

        /// <summary>GetReverseValueArrayY() : ピクセル単位の値配列YをScaleModeに従ってある単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayY()</para></remarks>
        public float[] RVAY(float[] Value)
        {
            return GetReverseValueArrayY(Value);
        }

        /// <summary>GetReversePoint() : ピクセル単位での座標点をScaleModeに従ってある単位での座標点に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点</param> 
        /// <returns>変換後の単位での座標点</returns> 
        /// <remarks>内部アクセス名<para>GetReversePoint()</para></remarks>
        public PointF RP(PointF Value)
        {
            return GetReversePoint(Value);
        }

        /// <summary>GetReverseArrayPoint() : ピクセル単位での座標点配列をScaleModeに従ってある単位での座標点配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点配列</param> 
        /// <returns>変換後の単位での座標点配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayPoint()</para></remarks>
        public PointF[] RAP(PointF[] Value)
        {
            return GetReverseArrayPoint(Value);
        }

        /// <summary>GetReverseValueSize() : ピクセル単位でのサイズをScaleModeに従ってある単位でのサイズに変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ</param> 
        /// <returns>変換後の単位でのサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueSize()</para></remarks>
        public SizeF RVS(SizeF Value)
        {
            return GetReverseValueSize(Value);
        }

        /// <summary>GetReverseValueArraySize() : ピクセル単位でのサイズ配列をScaleModeに従ってある単位でのサイズ配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ配列</param> 
        /// <returns>変換後の単位でのサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArraySize()</para></remarks>
        public SizeF[] RVAS(SizeF[] Value)
        {
            return GetReverseValueArraySize(Value);
        }
        #endregion

        #region その他の変換
        /// <summary>GetStepX() : 前の描画位置からの相対座標値Xを本来の座標値Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepX()</para></remarks>
        public float SX(float Value)
        {
            return GetStepX(Value);
        }

        /// <summary>GetStepY() : 前の描画位置からの相対座標値Yを本来の座標値Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepY()</para></remarks>
        public float SY(float Value)
        {
            return GetStepY(Value);
        }

        /// <summary>GetStepArrayX() : 前の描画位置からの相対座標値配列Xを本来の座標値配列Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayX()</para></remarks>
        public float[] SAX(float[] Value)
        {
            return GetStepArrayX(Value);
        }

        /// <summary>GetStepArrayY() : 前の描画位置からの相対座標値配列Yを本来の座標値配列Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayY()</para></remarks>
        public float[] SAY(float[] Value)
        {
            return GetStepArrayY(Value);
        }

        /// <summary>GetStepPoint() : 前の描画位置からの相対座標点を本来の座標点に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点</param>
        /// <returns>本来の座標点</returns>
        /// <remarks>内部アクセス名<para>GetStepPoint()</para></remarks>
        public PointF SP(PointF Value)
        {
            return GetStepPoint(Value);
        }

        /// <summary>GetStepArrayPoint() : 前の描画位置からの相対座標点配列を本来の座標点配列に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点配列</param>
        /// <returns>本来の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayPoint()</para></remarks>
        public PointF[] SAP(PointF[] Value)
        {
            return GetStepArrayPoint(Value);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public float[] PA(float[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public PointF[] PA(PointF[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public SizeF[] PA(SizeF[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public float[] PA(float[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public PointF[] PA(PointF[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public SizeF[] PA(SizeF[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }
        #endregion

        #region メソッドの中身の記述

        #region 内部通常変換
        internal float GetX(float X)
        {
            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    X = X - (this.XAxialDirection == AxialDirectionConstants.XAxial.Right ? this.ScaleLeft : this.ScaleLeft - this.ScaleWidth);
                    X = X * (this.ScaleImage.Width / this.ScaleWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    X = GetValueX(X);
                    break;
            }

            if (this.XAxialDirection == AxialDirectionConstants.XAxial.Left)
                X = this.ScaleImage.Width - X;

            return X;
        }

        internal float GetValueX(float VX)
        {
            float dpi = Graphics.FromHwnd(this.Handle).DpiX;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VX = VX * (this.ScaleImage.Width / this.ScaleWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                    VX = (VX / 1440.0f) * dpi;
                    break;

                case ScaleModeConstants.vbPoints:
                    VX = (VX / 72.0f) * dpi;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VX = ((VX * 120.0f) / 1440.0f) * dpi;
                    break;

                case ScaleModeConstants.vbInches:
                    VX = VX * dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VX = (VX / 25.4f) * dpi;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VX = (VX / 2.54f) * dpi;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VX = (VX / 2540.0f) * dpi;
                    break;
            }

            return VX;
        }

        internal float[] GetArrayX(float[] X)
        {
            float[] TX = new float[X.Length];

            for (int i = 0; i < X.Length; i++)
                TX[i] = GetX(X[i]);

            return TX;
        }

        internal float[] GetValueArrayX(float[] VX)
        {
            float[] TX = new float[VX.Length];

            for (int i = 0; i < VX.Length; i++)
                TX[i] = GetValueX(VX[i]);

            return TX;
        }

        internal float GetY(float Y)
        {
            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    Y = Y - (this.YAxialDirection == AxialDirectionConstants.YAxial.Bottom ? this.ScaleTop : this.ScaleTop - this.ScaleHeight);
                    Y = Y * (this.ScaleImage.Height / this.ScaleHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    Y = GetValueY(Y);
                    break;
            }

            if (this.YAxialDirection == AxialDirectionConstants.YAxial.Top)
                Y = this.ScaleImage.Height - Y;

            return Y;
        }

        internal float GetValueY(float VY)
        {
            float dpi = Graphics.FromHwnd(this.Handle).DpiX;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VY = VY * (this.ScaleImage.Height / this.ScaleHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                    VY = (VY / 1440.0f) * dpi;
                    break;

                case ScaleModeConstants.vbPoints:
                    VY = (VY / 72.0f) * dpi;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VY = ((VY * 120.0f) / 1440.0f) * dpi;
                    break;

                case ScaleModeConstants.vbInches:
                    VY = VY * dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VY = (VY / 25.4f) * dpi;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VY = (VY / 2.54f) * dpi;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VY = (VY / 2540.0f) * dpi;
                    break;
            }

            return VY;
        }

        internal float[] GetArrayY(float[] Y)
        {
            float[] TY = new float[Y.Length];

            for (int i = 0; i < Y.Length; i++)
                TY[i] = GetY(Y[i]);

            return TY;
        }

        internal float[] GetValueArrayY(float[] VY)
        {
            float[] TY = new float[VY.Length];

            for (int i = 0; i < VY.Length; i++)
                TY[i] = GetValueY(VY[i]);

            return TY;
        }

        internal PointF GetPoint(PointF P)
        {
            P.X = GetX(P.X);
            P.Y = GetY(P.Y);

            return P;
        }

        internal PointF[] GetArrayPoint(PointF[] P)
        {
            PointF[] TP = new PointF[P.Length];

            for (int i = 0; i < P.Length; i++)
            {
                TP[i].X = GetX(P[i].X);
                TP[i].Y = GetY(P[i].Y);
            }

            return TP;
        }

        internal SizeF GetValueSize(SizeF S)
        {
            S.Width = GetValueX(S.Width);
            S.Height = GetValueY(S.Height);

            return S;
        }

        internal SizeF[] GetValueArraySize(SizeF[] S)
        {
            SizeF[] TS = new SizeF[S.Length];

            for (int i = 0; i < S.Length; i++)
            {
                TS[i].Width = GetValueX(S[i].Width);
                TS[i].Height = GetValueY(S[i].Height);
            }

            return TS;
        }
        #endregion

        #region 内部逆変換
        internal float GetReverseX(float X)
        {
            if (this.XAxialDirection == AxialDirectionConstants.XAxial.Left)
                X = this.ScaleImage.Width - X;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    X = X * (this.ScaleWidth / this.ScaleImage.Width);
                    X = X + (this.XAxialDirection == AxialDirectionConstants.XAxial.Right ? this.ScaleLeft : this.ScaleLeft - this.ScaleWidth);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    X = GetReverseValueX(X);
                    break;
            }

            return X;
        }

        internal float GetReverseValueX(float VX)
        {
            float dpi = Graphics.FromHwnd(this.Handle).DpiX;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VX = VX * (this.ScaleWidth / this.ScaleImage.Width);
                    break;

                case ScaleModeConstants.vbTwips:
                    VX = (VX / dpi) * 1440.0f;
                    break;

                case ScaleModeConstants.vbPoints:
                    VX = (VX / dpi) * 72.0f;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VX = (VX * dpi) * 1440.0f / 120.0f;
                    break;

                case ScaleModeConstants.vbInches:
                    VX = VX / dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VX = (VX / dpi) * 25.4f;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VX = (VX / dpi) * 2.54f;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VX = (VX / dpi) * 2540.0f;
                    break;
            }

            return VX;
        }

        internal float[] GetReverseArrayX(float[] X)
        {
            float[] TX = new float[X.Length];

            for (int i = 0; i < X.Length; i++)
                TX[i] = GetReverseX(X[i]);

            return TX;
        }

        internal float[] GetReverseValueArrayX(float[] VX)
        {
            float[] TX = new float[VX.Length];

            for (int i = 0; i < VX.Length; i++)
                TX[i] = GetReverseValueX(VX[i]);

            return TX;
        }

        internal float GetReverseY(float Y)
        {
            if (this.YAxialDirection == AxialDirectionConstants.YAxial.Top)
                Y = this.ScaleImage.Height - Y;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    Y = Y * (this.ScaleHeight / this.ScaleImage.Height);
                    Y = Y + (this.YAxialDirection == AxialDirectionConstants.YAxial.Bottom ? this.ScaleTop : this.ScaleTop - this.ScaleHeight);
                    break;

                case ScaleModeConstants.vbTwips:
                case ScaleModeConstants.vbPoints:
                case ScaleModeConstants.vbPixels:
                case ScaleModeConstants.vbCharacters:
                case ScaleModeConstants.vbInches:
                case ScaleModeConstants.vbMillimeters:
                case ScaleModeConstants.vbCentimeters:
                case ScaleModeConstants.VbHimetric:
                    Y = GetReverseValueY(Y);
                    break;
            }

            return Y;
        }

        internal float GetReverseValueY(float VY)
        {
            float dpi = Graphics.FromHwnd(this.Handle).DpiY;

            switch (this.ScaleMode)
            {
                case ScaleModeConstants.vbUser:
                    VY = VY * (this.ScaleHeight / this.ScaleImage.Height);
                    break;

                case ScaleModeConstants.vbTwips:
                    VY = (VY / dpi) * 1440.0f;
                    break;

                case ScaleModeConstants.vbPoints:
                    VY = (VY / dpi) * 72.0f;
                    break;

                case ScaleModeConstants.vbPixels:
                    break;

                case ScaleModeConstants.vbCharacters:
                    VY = (VY * dpi) * 1440.0f / 120.0f;
                    break;

                case ScaleModeConstants.vbInches:
                    VY = VY / dpi;
                    break;

                case ScaleModeConstants.vbMillimeters:
                    VY = (VY / dpi) * 25.4f;
                    break;

                case ScaleModeConstants.vbCentimeters:
                    VY = (VY / dpi) * 2.54f;
                    break;

                case ScaleModeConstants.VbHimetric:
                    VY = (VY / dpi) * 2540.0f;
                    break;
            }

            return VY;
        }

        internal float[] GetReverseArrayY(float[] Y)
        {
            float[] TY = new float[Y.Length];

            for (int i = 0; i < Y.Length; i++)
                TY[i] = GetReverseY(Y[i]);

            return TY;
        }

        internal float[] GetReverseValueArrayY(float[] VY)
        {
            float[] TY = new float[VY.Length];

            for (int i = 0; i < VY.Length; i++)
                TY[i] = GetReverseValueY(VY[i]);

            return TY;
        }

        internal PointF GetReversePoint(PointF P)
        {
            P.X = GetReverseX(P.X);
            P.Y = GetReverseY(P.Y);

            return P;
        }

        internal PointF[] GetReverseArrayPoint(PointF[] P)
        {
            PointF[] TP = new PointF[P.Length];

            for (int i = 0; i < P.Length; i++)
            {
                TP[i].X = GetReverseX(P[i].X);
                TP[i].Y = GetReverseY(P[i].Y);
            }

            return TP;
        }

        internal SizeF GetReverseValueSize(SizeF S)
        {
            S.Width = GetReverseValueX(S.Width);
            S.Height = GetReverseValueY(S.Height);

            return S;
        }

        internal SizeF[] GetReverseValueArraySize(SizeF[] S)
        {
            SizeF[] TS = new SizeF[S.Length];

            for (int i = 0; i < S.Length; i++)
            {
                TS[i].Width = GetReverseValueX(S[i].Width);
                TS[i].Height = GetReverseValueY(S[i].Height);
            }

            return TS;
        }
        #endregion

        #region 内部その他の変換
        internal float GetStepX(float X)
        {
            return this.CurrentX + X;
        }

        internal float GetStepY(float Y)
        {
            return this.CurrentY + Y;
        }

        internal float[] GetStepArrayX(float[] X)
        {
            float[] TX = new float[X.Length];

            for (int i = 0; i < X.Length; i++)
                TX[i] = GetStepX(X[i]);

            return TX;
        }

        internal float[] GetStepArrayY(float[] Y)
        {
            float[] TY = new float[Y.Length];

            for (int i = 0; i < Y.Length; i++)
                TY[i] = GetStepY(Y[i]);

            return TY;
        }

        internal PointF GetStepPoint(PointF P)
        {
            P.X = GetStepX(P.X);
            P.Y = GetStepY(P.Y);

            return P;
        }

        internal PointF[] GetStepArrayPoint(PointF[] P)
        {
            PointF[] TP = new PointF[P.Length];

            for (int i = 0; i < P.Length; i++)
            {
                TP[i].X = GetStepX(P[i].X);
                TP[i].Y = GetStepY(P[i].Y);
            }

            return TP;
        }

        internal float[] GetPartialArray(float[] Value, int StartIndex, int EndIndex)
        {
            float[] TValue = new float[EndIndex - StartIndex + 1];

            Buffer.BlockCopy(Value, StartIndex * 4, TValue, 0, TValue.Length * 4);

            return TValue;
        }

        internal PointF[] GetPartialArray(PointF[] Value, int StartIndex, int EndIndex)
        {
            PointF[] TValue = new PointF[EndIndex - StartIndex + 1];

            Array.Copy(Value, StartIndex, TValue, 0, TValue.Length);

            return TValue;
        }

        internal SizeF[] GetPartialArray(SizeF[] Value, int StartIndex, int EndIndex)
        {
            SizeF[] TValue = new SizeF[EndIndex - StartIndex + 1];

            Array.Copy(Value, StartIndex, TValue, 0, TValue.Length);

            return TValue;
        }
        #endregion

        #endregion

        #endregion

        #region 提供メソッド(VB6.0に則っている)

        #region 図形描画
        /// <summary>直線を描く</summary> 
        /// <param name="X1">始点X</param>
        /// <param name="Y1">始点Y</param>
        /// <param name="X2">終点X 省略可 その場合始点Xの方を終点として扱う</param>
        /// <param name="Y2">終点Y 省略可 その場合始点Yの方を終点として扱う</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="LineStyle">直線のスタイル 省略可 その場合Lineとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBox.Line(X,Y) VB6.0のline -(X,Y)と同等</para> 
        /// <para>PictureBox.Line(X1,Y1,X2,Y2) VB6.0のline (X1,Y1) - (X2,Y2)と同等</para> 
        /// <para>PictureBox.Line(X1,Y1,X2,Y2,Information.QBColor(2),GraphicsStyle.LineStyle.BF) VB6.0のline (X1,Y1) - (X2,Y2),QBColor(2),BFと同等</para> 
        /// </example></remarks> 
        public void Line(float X1, float Y1, float? X2 = null, float? Y2 = null, ColorConstants? DrawColor = null, GraphicsStyle.LineStyle LineStyle = GraphicsStyle.LineStyle.Line)
        {
            if (this.TargetGraphics == null)
            {
                System.Windows.Forms.MessageBox.Show("Line : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (!X2.HasValue ^ !Y2.HasValue)
            {
                System.Windows.Forms.MessageBox.Show("Line : X2とY2の値は同時に指定してください。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            //X2,Y2が省略された場合Current～を始点X1,Y1を終点とする
            if (!X2.HasValue)
            {
                X2 = X1;
                X1 = this.CurrentX;
                Y2 = Y1;
                Y1 = this.CurrentY;
            }

            Pen DrawPen = (DrawColor.HasValue ? (System.Drawing.Pen)this.DrawPen.Clone() : this.DrawPen);

            if (DrawColor.HasValue)
                DrawPen.Color = Color.FromArgb((int)DrawColor.Value);

            //Line
            if (LineStyle == GraphicsStyle.LineStyle.Line)
            {
                PointF P1, P2;

                P1 = new PointF(GetX(X1), GetY(Y1));
                P2 = new PointF(GetX(X2.Value), GetY(Y2.Value));

                this.TargetGraphics.DrawLine(DrawPen, P1, P2);
            }

            else
            {
                RectangleF rect;
                float W, H, T, L;

                L = GetX(X1) < GetX(X2.Value) ? GetX(X1) : GetX(X2.Value);
                W = GetX(X1) < GetX(X2.Value) ? GetX(X2.Value) - GetX(X1) : GetX(X1) - GetX(X2.Value);
                T = GetY(Y1) < GetY(Y2.Value) ? GetY(Y1) : GetY(Y2.Value);
                H = GetY(Y1) < GetY(Y2.Value) ? GetY(Y2.Value) - GetY(Y1) : GetY(Y1) - GetY(Y2.Value);

                rect = new RectangleF(L, T, W, H);

                //FillRectangle
                if (LineStyle == GraphicsStyle.LineStyle.FillRectangle)
                {
                    using (Brush tb = new SolidBrush(DrawPen.Color))
                        this.TargetGraphics.FillRectangle(tb, rect);
                }

                //Rectangle
                else
                {
                    if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                    {
                        if (this.FillStyle == FillStyleConstants.vbFSSolid)
                        {
                            using (Brush tb = new SolidBrush(this.FillBrush.ForegroundColor))
                                this.TargetGraphics.FillRectangle(tb, rect);
                        }

                        else
                            this.TargetGraphics.FillRectangle(this.FillBrush, rect);
                    }

                    this.TargetGraphics.DrawRectangle(DrawPen, rect.X, rect.Y, rect.Width, rect.Height);
                }
            }

            if (DrawColor.HasValue)
            {
                DrawPen.Dispose();
                this.DrawColor = DrawColor.Value;
            }

            this.CurrentX = X2.Value;
            this.CurrentY = Y2.Value;

            TryAutoRedraw();
        }

        /// <summary>指定された4つ以上の点を繋ぐ曲線を描く</summary>
        /// <param name="X">点の座標配列X</param>
        /// <param name="Y">点の座標配列Y</param>
        /// <param name="CurrentValueUsed">始点をCurrent～にするかどうか 省略可 その場合はFalseになる</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="Tension">曲線の滑らかさを0～1で指定する 省略可 その場合0.5になる</param>
        /// <param name="CurveStyle">曲線のスタイル 省略可 その場合Curveとなる</param>
        /// <remarks>
        /// <example>メソッドの使用例 
        /// <para>PictureBox.Curve(X,Y)</para>
        /// <para>PictureBox.Curve(X,Y,True,Information.QBColor(2),1.0)</para>
        /// <para>PictureBox.Curve(X,Y, ,Information.QBColor(2), ,GraphicsStyle.CurveStyle.FillCurve)</para>
        /// </example></remarks>
        public void Curve(float[] X, float[] Y, bool? CurrentValueUsed = false, ColorConstants? DrawColor = null, float? Tension = 0.5f, GraphicsStyle.CurveStyle CurveStyle = GraphicsStyle.CurveStyle.Curve)
        {
            if (X.Length != Y.Length)
            {
                System.Windows.Forms.MessageBox.Show("Curve : XとYの値の数が合いません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            PointF[] P = new PointF[X.Length];

            for (int i = 0; i < P.Length; i++)
            {
                P[i].X = X[i];
                P[i].Y = Y[i];
            }

            Curve(P, CurrentValueUsed, DrawColor, Tension, CurveStyle);
        }

        /// <summary>指定された4つ以上の点を繋ぐ曲線を描く</summary>
        /// <param name="P">点の座標配列</param>
        /// <param name="CurrentValueUsed">始点をCurrent～にするかどうか 省略可 その場合はFalseになる</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="Tension">曲線の滑らかさを0～1で指定する 省略可 その場合0.5になる</param>
        /// <param name="CurveStyle">曲線のスタイル 省略可 その場合Curveとなる</param>
        /// <remarks>
        /// <example>メソッドの使用例 
        /// <para>PictureBox.Curve(P)</para>
        /// <para>PictureBox.Curve(P,True,Information.QBColor(2),1.0)</para>
        /// <para>PictureBox.Curve(P, ,Information.QBColor(2), ,GraphicsStyle.CurveStyle.FillCurve)</para>
        /// </example></remarks>
        public void Curve(PointF[] P, bool? CurrentValueUsed = false, ColorConstants? DrawColor = null, float? Tension = 0.5f, GraphicsStyle.CurveStyle CurveStyle = GraphicsStyle.CurveStyle.Curve)
        {
            if ((!CurrentValueUsed.HasValue || !CurrentValueUsed.Value) ? P.Length < 3 : P.Length < 4)
            {
                System.Windows.Forms.MessageBox.Show("Curve : 点の数が4つ未満では曲線を定められません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (!Tension.HasValue)
                Tension = 0.5f;

            //Current～を始点とする場合の動作
            if (CurrentValueUsed.HasValue && CurrentValueUsed.Value)
            {
                Array.Resize<PointF>(ref P, P.Length + 1);

                for (int i = P.Length - 1; i >= 1; i--)
                    P[i] = P[i - 1];

                P[0].X = this.CurrentX;
                P[0].Y = this.CurrentY;
            }

            Pen DrawPen = (!DrawColor.HasValue ? this.DrawPen : (System.Drawing.Pen)this.DrawPen.Clone());

            if (DrawColor.HasValue)
                DrawPen.Color = Color.FromArgb((int)DrawColor.Value);

            //Curve
            if (CurveStyle == GraphicsStyle.CurveStyle.Curve)
                this.TargetGraphics.DrawCurve(DrawPen, GetArrayPoint(P), Tension.Value);

            //FillCurve
            else if (CurveStyle == GraphicsStyle.CurveStyle.FillAlternateCurve || CurveStyle == GraphicsStyle.CurveStyle.FillWindingCurve)
            {
                using (Brush tb = new SolidBrush(DrawPen.Color))
                    this.TargetGraphics.FillClosedCurve(tb, GetArrayPoint(P), (CurveStyle == GraphicsStyle.CurveStyle.FillAlternateCurve ? System.Drawing.Drawing2D.FillMode.Alternate : System.Drawing.Drawing2D.FillMode.Winding), Tension.Value);
            }

            //CloseCurve
            else
            {
                if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                {
                    if (this.FillStyle == FillStyleConstants.vbFSSolid)
                    {
                        using (Brush tb = new SolidBrush(this.FillBrush.ForegroundColor))
                            this.TargetGraphics.FillClosedCurve(tb, GetArrayPoint(P), (CurveStyle == GraphicsStyle.CurveStyle.CloseAlternateCurve ? System.Drawing.Drawing2D.FillMode.Alternate : System.Drawing.Drawing2D.FillMode.Winding), Tension.Value);
                    }

                    else
                        this.TargetGraphics.FillClosedCurve(this.FillBrush, GetArrayPoint(P), (CurveStyle == GraphicsStyle.CurveStyle.CloseAlternateCurve ? System.Drawing.Drawing2D.FillMode.Alternate : System.Drawing.Drawing2D.FillMode.Winding), Tension.Value);
                }

                this.TargetGraphics.DrawClosedCurve(DrawPen, GetArrayPoint(P), Tension.Value, (CurveStyle == GraphicsStyle.CurveStyle.CloseAlternateCurve ? System.Drawing.Drawing2D.FillMode.Alternate : System.Drawing.Drawing2D.FillMode.Winding));
            }

            if (DrawColor.HasValue)
            {
                DrawPen.Dispose();
                this.DrawColor = DrawColor.Value;
            }

            this.CurrentX = P[P.Length - 1].X;
            this.CurrentY = P[P.Length - 1].Y;

            TryAutoRedraw();
        }

        /// <summary>点を描く</summary> 
        /// <param name="X">中心の座標X</param> 
        /// <param name="Y">中心の座標Y</param> 
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param> 
        /// <remarks> 
        /// <example>メソッドの使用例 
        /// <para>PictureBox.PSet(X,Y) VB6.0のPSet (X,Y)と同等</para> 
        /// <para>PictureBox.PSet(X,Y,Information.QBColor(3)) VB6.0のPSet (X,Y),QBColor(3)と同等</para> 
        /// </example></remarks> 
        public void PSet(float X, float Y, ColorConstants? DrawColor = null)
        {
            if (this.TargetGraphics == null)
            {
                System.Windows.Forms.MessageBox.Show("PSet : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            Color tcolor;

            if (!DrawColor.HasValue)
                DrawColor = (ColorConstants)this.DrawPen.Color.ToArgb();

            tcolor = System.Drawing.Color.FromArgb((int)DrawColor.Value);

            using (Brush tb = new SolidBrush(tcolor))
                this.TargetGraphics.FillEllipse(tb, GetX(X) - 1.5f, GetY(Y) - 1.5f, 3.0f, 3.0f);

            this.CurrentX = X;
            this.CurrentY = Y;

            if (DrawColor.HasValue)
                this.DrawColor = DrawColor.Value;

            TryAutoRedraw();
        }

        /// <summary>円を描く(角度指定はStartRadから開始のEndRadで終了で角度とその方向を決めるプラスが左回り)</summary> 
        /// <param name="X">中心の座標X</param> 
        /// <param name="Y">中心の座標Y</param> 
        /// <param name="R">半径を指定 0.0より大きい値(X軸の単位)</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <param name="StartRad">開始角度(ラジアン) 省略可 その場合0となる</param>
        /// <param name="EndRad">終了角度(ラジアン) 省略可 その場合2πとなる</param> 
        /// <param name="Aspect">アスペクト比(縦/横) 省略可 その場合1となる</param>
        /// <param name="CircleStyle">円のスタイル(VB6.0での円弧・扇形の指定はここで) 省略可 その場合Arcとなる</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBox.Circle(X,Y,R) VB6.0のCircle (X,Y),Rと同等</para> 
        /// <para>PictureBox.Circle(X,Y,R,C, , ,ASP) VB6.0のCircle (X,Y),R,C, , ,ASPと同等(C:色 ASP:アスペクト比)</para> 
        /// </example></remarks> 
        public void Circle(float X, float Y, float R, ColorConstants? DrawColor = null, float? StartRad = 0.0f, float? EndRad = (float)(2.0 * Math.PI), float? Aspect = 1.0f, GraphicsStyle.CircleStyle CircleStyle = GraphicsStyle.CircleStyle.Arc)
        {
            if (this.TargetGraphics == null)
            {
                System.Windows.Forms.MessageBox.Show("Crcle ： Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (R <= 0.0f)
            {
                System.Windows.Forms.MessageBox.Show("Crcle ： Rの値は0.0より大きい値で指定してください。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (!StartRad.HasValue)
                StartRad = 0.0f;

            if (!EndRad.HasValue)
                EndRad = (float)(2.0 * Math.PI);

            if (!Aspect.HasValue)
                Aspect = 1.0f;

            float SHX, SHY;
            Pen DrawPen = (!DrawColor.HasValue ? this.DrawPen : (System.Drawing.Pen)this.DrawPen.Clone());

            if (DrawColor.HasValue)
                DrawPen.Color = Color.FromArgb((int)DrawColor.Value);

            //アスペクト比に従ってXの半径とYの半径を決める
            SHX = GetValueX(Aspect < 1.0f ? R / Aspect.Value : R);
            SHY = GetValueX(Aspect > 1.0f ? R * Aspect.Value : R);

            //StartRadとEndRadの差が2π未満ならば
            if (Math.Abs(EndRad.Value - StartRad.Value) < (float)(2.0 * Math.PI))
            {
                bool flag = false;

                //StartRadがマイナスならばプラスにする
                while (StartRad < 0.0f)
                    StartRad += (float)(2.0 * Math.PI);

                //EndRadがマイナスならばプラスにしてflag=trueにする
                while (EndRad < 0.0f)
                {
                    EndRad += (float)(2.0 * Math.PI);
                    flag = true;
                }

                //最終的に使うのは始点と角度なので角度を計算する
                EndRad = EndRad.Value - StartRad.Value;

                if (EndRad < 0.0f && flag == false)
                    EndRad += (float)(2.0 * Math.PI);

                else if (EndRad > 0.0f && flag == true)
                    EndRad -= (float)(2.0 * Math.PI);

                //.NET用の回転方向と度数単位に合わせる
                StartRad = (float)(-StartRad.Value * 180.0 / Math.PI);
                EndRad = (float)(-EndRad.Value * 180.0 / Math.PI);
            }

            //StartRadとEndRadの差が2π以上ならば
            else
            {
                StartRad = 0.0f;
                EndRad = 360.0f;
            }

            //Arc
            if (CircleStyle == GraphicsStyle.CircleStyle.Arc)
                this.TargetGraphics.DrawArc(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0f, SHY * 2.0f, StartRad.Value, EndRad.Value);

            //FillPie
            else if (CircleStyle == GraphicsStyle.CircleStyle.FillPie)
            {
                using (Brush tb = new SolidBrush(DrawPen.Color))
                    this.TargetGraphics.FillPie(tb, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0f, SHY * 2.0f, StartRad.Value, EndRad.Value);
            }

            //Pie
            else
            {
                if (this.FillStyle != FillStyleConstants.vbFSTransparent)
                {
                    if (this.FillStyle == FillStyleConstants.vbFSSolid)
                    {
                        using (Brush tb = new SolidBrush(this.FillBrush.ForegroundColor))
                            this.TargetGraphics.FillPie(tb, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0f, SHY * 2.0f, StartRad.Value, EndRad.Value);
                    }

                    else
                        this.TargetGraphics.FillPie(this.FillBrush, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0f, SHY * 2.0f, StartRad.Value, EndRad.Value);
                }

                if (Math.Abs(EndRad.Value) >= 360.0f)
                    this.TargetGraphics.DrawEllipse(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0f, SHY * 2.0f);

                else
                    this.TargetGraphics.DrawPie(DrawPen, GetX(X) - SHX, GetY(Y) - SHY, SHX * 2.0f, SHY * 2.0f, StartRad.Value, EndRad.Value);
            }

            if (DrawColor.HasValue)
            {
                DrawPen.Dispose();
                this.DrawColor = DrawColor.Value;
            }

            this.CurrentX = X;
            this.CurrentY = Y;

            TryAutoRedraw();
        }
        #endregion

        #region テキスト・画像描画
        /// <summary>文字列を描く(フォントはプロパティDrawFont、フォントカラーはプロパティDrawColorまたは指定した色に依存)</summary>
        /// <param name="DrawString">描きたい文字列</param>
        /// <param name="X">文字列の左上端座標のX 省略可 その場合CurrentXの値を使用</param>
        /// <param name="Y">文字列の左上端座標のY 省略可 その場合CurrentYの値を使用</param>
        /// <param name="DrawColor">色(ColorConstants形式(ARGB形式)) 省略可</param>
        /// <remarks> 
        /// <example>メソッドの使用例
        /// <para>PictureBox.Print("ABC") VB6.0のPrint "ABC"同等(Curent～で予めX,Yを決めておく)</para> 
        /// </example></remarks> 
        public void Print(string DrawString, float? X = null, float? Y = null, ColorConstants? DrawColor = null)
        {
            if (this.TargetGraphics == null)
            {
                System.Windows.Forms.MessageBox.Show("Print : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (!X.HasValue ^ !Y.HasValue)
            {
                System.Windows.Forms.MessageBox.Show("Print : XとYの値は同時に指定してください。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            //X,Yが与えられなかった場合Current～を使う
            if (!X.HasValue)
            {
                X = this.CurrentX;
                Y = this.CurrentY;
            }

            Color tc = (DrawColor.HasValue ? Color.FromArgb((int)DrawColor.Value) : this.DrawPen.Color);

            using (Brush tb = new SolidBrush(tc))
                this.TargetGraphics.DrawString(DrawString, this.DrawFont, tb, GetX(X.Value), GetY(Y.Value));

            this.CurrentX = X.Value;
            this.CurrentY = Y.Value;

            if (DrawColor.HasValue)
                this.DrawColor = DrawColor.Value;

            TryAutoRedraw();
        }

        #region PaintPictureを再現するためのWindowsAPIのインポート
        /// <summary>APIを使用するクラス</summary>
        private class NativeMethods
        {
            /// <summary>コピー元の長方形からコピー先の長方形へビットマップをコピーする</summary>
            /// <param name="hDestDC">コピー先のデバインコンテキストハンドル</param>
            /// <param name="nDestLeft">コピー先の描画する左端</param>
            /// <param name="nDestTop">コピー先の描画する上端</param>
            /// <param name="nDestWidth">コピー先の描画する幅</param>
            /// <param name="nDestHeight">コピー先の描画する高さ</param>
            /// <param name="hSrcDC">コピー元のデバインコンテキストハンドル</param>
            /// <param name="nSrcLeft">コピー元の取得範囲の左端</param>
            /// <param name="nSrcTop">コピー元の取得範囲の上端</param>
            /// <param name="nSrcWidth">コピー元の取得範囲の幅</param>
            /// <param name="nSrcHeight">コピー元の取得範囲の高さ</param>
            /// <param name="dwRop">コピー時のラスターオペレーション</param>
            /// <returns>成功したかどうか 成功するとTrueが戻る</returns>
            [System.Runtime.InteropServices.DllImport("gdi32.dll")]
            public static extern bool StretchBlt(IntPtr hDestDC, int nDestLeft, int nDestTop, int nDestWidth, int nDestHeight, IntPtr hSrcDC, int nSrcLeft, int nSrcTop, int nSrcWidth, int nSrcHeight, RasterOpConstants dwRop);

            /// <summary>伸縮描画するAPIの伸縮モードを指定する</summary>
            /// <param name="hdc">StretchBltでのコピー先のデバインコンテキストハンドル</param>
            /// <param name="iStertchMode">伸縮モード</param>
            /// <returns>前の伸縮モード</returns>
            [System.Runtime.InteropServices.DllImport("gdi32.dll")]
            public static extern StretchMode SetStretchBltMode(IntPtr hdc, StretchMode iStertchMode);

            /// <summary>指定されたデバイスコンテキストで、指定された 1 個のオブジェクトを選択する</summary>
            /// <param name="hdc">対象のデバインコンテキストハンドル</param>
            /// <param name="hgdiobj">指定するオブジェクトハンドル</param>
            /// <returns>置き換えが発生する前のオブジェクトのハンドル</returns>
            [System.Runtime.InteropServices.DllImport("gdi32.dll")]
            public static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);

            /// <summary>オブジェクトを削除し、そのオブジェクトに関連付けられていたすべてのシステムリソースを解放する</summary>
            /// <param name="hObject">対象のオブジェクトハンドル</param>
            /// <returns>成功したかどうか 成功するとTrueが戻る</returns>
            [System.Runtime.InteropServices.DllImport("gdi32.dll")]
            public static extern bool DeleteObject(IntPtr hObject);

            /// <summary>SetStretchBltModeに使用する伸縮モード</summary>
            public enum StretchMode : int
            {
                /// <summary>既存のカラー値と AND 演算する。(黒 > 白)</summary>
                BLACKONWHITE = 1,
                /// <summary>既存のカラー値と OR 演算する。(白 > 黒)</summary>
                WHITEONBLACK = 2,
                /// <summary>コピー先のピクセルをコピー元のピクセルで置換する</summary>
                COLORONCOLOR = 3,
                /// <summary>コピー先のピクセルの平均カラー値をとる</summary>
                HALFTONE = 4,
                /// <summary>HALFTONE と同じ</summary>
                MAXSTRETCHBLTMODE = 4
            }
        }
        #endregion

        /// <summary>イメージを描画する</summary>
        /// <param name="Source">描画するイメージ</param>
        /// <param name="X">描画したい場所の左上端座標X(ScaleMode単位)</param>
        /// <param name="Y">描画したい場所の左上端座標Y(ScaleMode単位)</param>
        /// <param name="Width">描画したい場所範囲の幅(ScaleMode単位) 省略可</param>
        /// <param name="Height">描画したい場所範囲の高さ(ScaleMode単位) 省略可</param>
        /// <param name="SrcX">描画したいイメージの部分範囲の左上端座標X(ピクセル単位) 省略可</param>
        /// <param name="SrcY">描画したいイメージの部分範囲の左上端座標Y(ピクセル単位) 省略可</param>
        /// <param name="SrcWidth">描画したいイメージの部分範囲の幅(ピクセル単位) マイナスの値で反転可 省略可</param>
        /// <param name="SrcHeight">描画したいイメージの部分範囲の高さ(ピクセル単位) マイナスの値で反転可 省略可</param>
        /// <param name="RasterOP">ラスターオペレーション 省略可 その場合vbSrcCopyとなる 半透明画像はvbSrcCopy以外では扱えない(画像がぼける) 不透明度と同時に指定は不可、同時指定の場合不透明度が優先される</param>
        /// <param name="SourceAlpha">描画したいイメージの不透明度(0.0～1.0) 省略化 その場合1.0となる ラスターオペレーションと同時に指定は不可、同時指定の場合不透明度が優先される</param>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.PaintPicture(img,X,Y) VB6.0のPaintPicture img,X,Yと同等</para>
        /// <para>PictureBox.PaintPicture(img,X1,Y1,W1,H1,X2,Y2,W2,H2) VB6.0のPaintPicture img,X1,Y1,W1,H1,X2,Y2,W2,H2と同等</para>
        /// </example></remarks>
        [System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityAction.LinkDemand,Flags = System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode)]
        public void PaintPicture(System.Drawing.Image Source, float X, float Y, float? Width = null, float? Height = null, int? SrcX = null, int? SrcY = null, int? SrcWidth = null, int? SrcHeight = null, RasterOpConstants? RasterOP = RasterOpConstants.vbSrcCopy, float SourceAlpha = 1.0f)
        {
            if (this.TargetGraphics == null)
            {
                System.Windows.Forms.MessageBox.Show("PaintPicture : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if (0.0f > SourceAlpha || SourceAlpha > 1.0f)
            {
                System.Windows.Forms.MessageBox.Show("PaintPicture : SourceAlphaの値は0.0～1.0の間です。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            if ((!Width.HasValue ^ !Height.HasValue) || (!SrcWidth.HasValue ^ !SrcHeight.HasValue))
            {
                System.Windows.Forms.MessageBox.Show("PaintPicture : WidthとHeightやSrcWidthとSrcHeightの値は同時に指定してください。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            else if (!SrcX.HasValue ^ !SrcY.HasValue)
            {
                System.Windows.Forms.MessageBox.Show("PaintPicture : SrcXとSrcYの値は同時に指定してください。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            Width = (Width.HasValue ? GetValueX(Width.Value) : this.ScaleImage.Width);
            Height = (Height.HasValue ? GetValueY(Height.Value) : this.ScaleImage.Height);

            SrcX = (SrcX.HasValue ? SrcX : 0);
            SrcY = (SrcY.HasValue ? SrcY : 0);
            SrcWidth = (SrcWidth.HasValue ? SrcWidth : Source.Width);
            SrcHeight = (SrcHeight.HasValue ? SrcHeight : Source.Height);

            if (Width <= 0.0f || Height <= 0.0f)
            {
                System.Windows.Forms.MessageBox.Show("PaintPicture : WidthとHeightはプラスの値で表記してください。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            else if (SrcWidth == 0 || SrcHeight == 0)
            {
                System.Windows.Forms.MessageBox.Show("PaintPicture : SrcWidthとSrcHeightに0は指定できません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            //SourceAlphaが1.0でRasterOPがvbSrcCopyの時またはSourceAlphaが1.0ではない時
            if (!RasterOP.HasValue || RasterOP == RasterOpConstants.vbSrcCopy || SourceAlpha != 1.0f)
            {
                System.Drawing.Imaging.ColorMatrix cm = new System.Drawing.Imaging.ColorMatrix();
                cm.Matrix00 = 1.0f;
                cm.Matrix11 = 1.0f;
                cm.Matrix22 = 1.0f;
                cm.Matrix33 = SourceAlpha;
                cm.Matrix44 = 1.0f;

                using (System.Drawing.Imaging.ImageAttributes ia = new System.Drawing.Imaging.ImageAttributes())
                {
                    ia.SetColorMatrix(cm);

                    this.TargetGraphics.DrawImage(Source, new Rectangle((int)GetX(X), (int)GetY(Y), (int)Width.Value, (int)Height.Value), SrcX.Value, SrcY.Value, SrcWidth.Value, SrcHeight.Value, GraphicsUnit.Pixel, ia);
                }
            }

            //SourceAlphaが1.0でRasterOPがvbSrcCopyでない時
            else
            {
                Graphics grImg = Graphics.FromImage(Source);
                IntPtr hDC = this.TargetGraphics.GetHdc();
                IntPtr imgDC = grImg.GetHdc();
                IntPtr hBitmap = ((System.Drawing.Bitmap)Source).GetHbitmap();
                IntPtr oldBitmap = NativeMethods.SelectObject(imgDC, hBitmap);

                //StretchModeを設定してからStretchBltで描画対象にRasterOPに従って伸縮部分描画する
                NativeMethods.SetStretchBltMode(hDC, (this.DrawCompositingMode == System.Drawing.Drawing2D.CompositingMode.SourceOver ? NativeMethods.StretchMode.MAXSTRETCHBLTMODE : NativeMethods.StretchMode.COLORONCOLOR));
                NativeMethods.StretchBlt(hDC, (int)GetX(X), (int)GetY(Y), (int)Width.Value, (int)Height.Value, imgDC, SrcX.Value, SrcY.Value, SrcWidth.Value, SrcHeight.Value, RasterOP.Value);

                NativeMethods.SelectObject(imgDC, oldBitmap);
                NativeMethods.DeleteObject(hBitmap);

                //デバインコンテキストハンドルの開放
                this.TargetGraphics.ReleaseHdc(hDC);
                grImg.ReleaseHdc(imgDC);

                grImg.Dispose();
            }

            this.CurrentX = X;
            this.CurrentY = Y;
            TryAutoRedraw();
        }
        #endregion

        #region その他
        /// <summary>画面消去</summary>
        public void Cls()
        {
            if (this.TargetGraphics == null)
            {
                System.Windows.Forms.MessageBox.Show("Cls : Starting_Initしてない状態・Interruptで中断している状態ではこのメソッドは使えません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            Color tmp = Color.FromArgb(0, 0, 0, 0);
            this.TargetGraphics.Clear(tmp);

            TryAutoRedraw();
        }

        /// <summary>オブジェクトを移動する (スクリーン座標系、ピクセル単位)</summary>
        /// <param name="Left">オーナー座標(通常はForm内の座標)での左端の座標X</param>
        /// <param name="Top">オーナー座標(通常はForm内の座標)での上端の座標Y</param>
        /// <param name="Width">オブジェクトの幅</param>
        /// <param name="Height">オブジェクトの高さ</param>
        /// <remarks>
        /// <example>メソッド使用例
        /// <para>PictureBox.MoveObject(10,10,500,500) VB6.0のMove 10,10,500,500 とほぼ同等(単位はピクセルのみになる：オーナー座標(10,10)に500×500の大きさで再配置する)</para>
        /// </example></remarks>
        public void MoveObject(int Left, int Top, int Width, int Height)
        {
            if (Width < 0 || Height < 0)
            {
                System.Windows.Forms.MessageBox.Show("MoveObject : WidthとHeightにマイナスの値は指定できません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            base.Left = Left;
            base.Top = Top;
            base.Width = Width;
            base.Height = Height;
        }

        /// <summary>指定した座標の色を返す(ColorConstants形式(ARGB形式))</summary> 
        /// <param name="X">座標X</param> 
        /// <param name="Y">座標Y</param> 
        /// <returns>色(ColorConstants形式(ARGB形式))</returns>
        /// <remarks><example>メソッドの使用例<para>PictureBox.Point(10,10) VB6.0のPoint 10,10 と同等</para></example></remarks>
        public ColorConstants Point(float X, float Y)
        {
            return (ColorConstants)this.ScaleImage.GetPixel((int)(GetX(X) + 0.5f), (int)(GetY(Y) + 0.5f)).ToArgb();
        }

        /// <summary>現在のフォントである文字列をプリントしたときの文字列の幅を取得する</summary>
        /// <param name="Str">幅が知りたい文字列</param>
        /// <returns>Strをプリントした時の幅</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.TextWidth("ABC") VB6.0のTextWidth "ABC" と同等</para>
        /// </example></remarks>
        public float TextWidth(string Str)
        {
            return GetReverseValueX(this.TargetGraphics.MeasureString(Str, this.DrawFont).Width);
        }

        /// <summary>現在のフォントである文字列をプリントしたときの文字列の高さを取得する</summary>
        /// <param name="Str">高さが知りたい文字列</param>
        /// <returns>Strをプリントした時の高さ</returns>
        /// <remarks>
        /// <example>メソッドの使用例
        /// <para>PictureBox.TextHeight("ABC") VB6.0のTextHeight "ABC" と同等</para>
        /// </example></remarks>
        public float TextHeight(string Str)
        {
            return GetReverseValueY(this.TargetGraphics.MeasureString(Str, this.DrawFont).Height);
        }
        #endregion

        #endregion
    }
    #endregion

    #region PictureBoxUnitConvertクラス
    /// <summary>単位変換メソッドのみを管理するクラス VB60.PictureBoxから単位変換メソッドのみを抜き出してインスタンスを作る</summary>
    /// <remarks>クラスの利用方法(VB.NET)
    /// <para>Dim A As VB60.PictureBox = New VB60.PictureBox()</para>
    /// <para>A.YAxialDirection = AxialDirectionConstants.YAxial.Top等</para>
    /// <para>A.Init_Scale(-1,1,2,2) →数学座標の-1～1の幅高さそれぞれ2の仮想座標の設定</para>
    /// <para>A.Starting_Init()</para>
    /// <para>Dim B As VB60.PictureBoxUnitConvert = New VB60.PictureBoxUnitConvert(A)</para>
    /// <para>Dim C As Single = B.GetX(0)等と使う</para>
    /// <para> </para>
    /// <para>以下単位変換メソッドの説明</para>
    /// <para>単位変換メソッドはGet～という名前で定義されている</para>
    /// <para>GetXなどはScaleModeの座標系からピクセル単位のスクリーン座標系に変換する通常メソッド</para>
    /// <para>GetReverseXなどReverseが付くと先ほどの通常変換の逆変換になる</para>
    /// <para>GetValueXなどValueが付くものは原点関係なしで幅や高さを取得する変換メソッドである</para>
    /// <para>GetArrayXなどArrayが付くものは配列に関する変換メソッドである</para>
    /// <para>Get～の一番右側が取得する値の種類を表す(種類：X,Y,Point,Size,Array)</para>
    /// <para>GetStepXなどの特殊変換も存在する</para>
    /// <para>省略はGetを除いた単語の先頭のアルファベットを並べた物である</para>
    /// <para>例えばGetReverseValueArraySizeの省略はRVASである</para>
    /// </remarks>
    [System.ComponentModel.ToolboxItem(false)]
    public class PictureBoxUnitConvert
    {
        #region フィールドとコンストラクタ、隠蔽メソッド
        /// <summary>単位変換の対象となるVB60.PictureBox</summary>
        private PictureBox Target;
        /// <summary>単位変換メソッドの詳細をメソッド一覧に表示するかどうかのパラメータ</summary>
        private const EditorBrowsableState EBState = EditorBrowsableState.Advanced;

        /// <summary>新しくインスタンスを作る</summary>
        /// <param name="Target">単位変換の対象となるVB60.PictureBox</param>
        public PictureBoxUnitConvert(PictureBox Target)
        {
            if (Target == null || !Target.StartEnabled)
            {
                System.Windows.Forms.MessageBox.Show("コンストラクタ : 引数のVB60.PictureBoxがNothing(null)またはStarting_Initをしていない状態でこのクラスのインスタンスは作れません。", "エラー", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Error);
                return;
            }

            this.Target = Target;
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的Equals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool Equals(object objA, object objB)
        {
            return Object.Equals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>Objectクラスの静的ReferenceEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static new bool ReferenceEquals(object objA, object objB)
        {
            return Object.ReferenceEquals(objA, objB);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetType</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public new Type GetType()
        {
            return base.GetType();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのEquals</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのGetHashCode</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>通常に使えるがエディタからは見えない</summary>
        /// <returns>ObjectクラスのToString</returns>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override string ToString()
        {
            return base.ToString();
        } 
        #endregion

        #region 単位変換メソッド

        #region 通常変換
        /// <summary>GetX() : ScaleModeに従ってある単位での座標Xをピクセル単位での座標Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetX()</para></remarks>
        public float X(float Value)
        {
            return GetX(Value);
        }

        /// <summary>GetY() : ScaleModeに従ってある単位での座標Yをピクセル単位での座標Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        /// <remarks>内部アクセス名<para>GetY()</para></remarks>
        public float Y(float Value)
        {
            return GetY(Value);
        }

        /// <summary>GetArrayX() : ScaleModeに従ってある単位での座標配列Xをピクセル単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayX()</para></remarks>
        public float[] AX(float[] Value)
        {
            return GetArrayX(Value);
        }

        /// <summary>GetArrayY() : ScaleModeに従ってある単位での座標配列Yをピクセル単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetArrayY()</para></remarks>
        public float[] AY(float[] Value)
        {
            return GetArrayY(Value);
        }

        /// <summary>GetValueX() : ScaleModeに従ってある単位の値Xをピクセル単位の値Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueX()</para></remarks>
        public float VX(float Value)
        {
            return GetValueX(Value);
        }

        /// <summary>GetValueY() : ScaleModeに従ってある単位の値Yをピクセル単位の値Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        /// <remarks>内部アクセス名<para>GetValueY()</para></remarks>
        public float VY(float Value)
        {
            return GetValueY(Value);
        }

        /// <summary>GetValueArrayX() : ScaleModeに従ってある単位の値配列Xをピクセル単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayX()</para></remarks>
        public float[] VAX(float[] Value)
        {
            return GetValueArrayX(Value);
        }

        /// <summary>GetValueArrayY() : ScaleModeに従ってある単位の値配列Yをピクセル単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArrayY()</para></remarks>
        public float[] VAY(float[] Value)
        {
            return GetValueArrayY(Value);
        }

        /// <summary>GetPoint() : ScaleModeに従ってある単位の座標点をピクセル単位の座標点に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点</param>
        /// <returns>ピクセル単位の座標点</returns>
        /// <remarks>内部アクセス名<para>GetPoint()</para></remarks>
        public PointF P(PointF Value)
        {
            return GetPoint(Value);
        }

        /// <summary>GetArrayPoint() : ScaleModeに従ってある単位の座標点配列をピクセル単位の座標点配列に変換して返す</summary>
        /// <param name="Value">変換前の単位での座標点配列</param>
        /// <returns>ピクセル単位の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetArrayPoint()</para></remarks>
        public PointF[] AP(PointF[] Value)
        {
            return GetArrayPoint(Value);
        }

        /// <summary>GetValueSize() : ScaleModeに従ってある単位のサイズをピクセル単位のサイズに変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ</param> 
        /// <returns>ピクセル単位のサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetValueSize()</para></remarks>
        public SizeF VS(SizeF Value)
        {
            return GetValueSize(Value);
        }

        /// <summary>GetValueArraySize() : ScaleModeに従ってある単位のサイズ配列をピクセル単位のサイズ配列に変換して返す</summary> 
        /// <param name="Value">変換前の単位でのサイズ配列</param> 
        /// <returns>ピクセル単位のサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetValueArraySize()</para></remarks>
        public SizeF[] VAS(SizeF[] Value)
        {
            return GetValueArraySize(Value);
        }
        #endregion

        #region 逆変換
        /// <summary>GetReverseX() : ピクセル単位での座標XをScaleModeに従ってある単位での座標Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseX()</para></remarks>
        public float RX(float Value)
        {
            return GetReverseX(Value);
        }

        /// <summary>GetReverseY() : ピクセル単位での座標YをScaleModeに従ってある単位での座標Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseY()</para></remarks>
        public float RY(float Value)
        {
            return GetReverseY(Value);
        }

        /// <summary>GetReverseArrayX() : ピクセル単位での座標配列XをScaleModeに従ってある単位での座標配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayX()</para></remarks>
        public float[] RAX(float[] Value)
        {
            return GetReverseArrayX(Value);
        }

        /// <summary>GetReverseArrayY() : ピクセル単位での座標配列YをScaleModeに従ってある単位での座標配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayY()</para></remarks>
        public float[] RAY(float[] Value)
        {
            return GetReverseArrayY(Value);
        }

        /// <summary>GetReverseValueX() : ピクセル単位の値XをScaleModeに従ってある単位の値Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueX()</para></remarks>
        public float RVX(float Value)
        {
            return GetReverseValueX(Value);
        }

        /// <summary>GetReverseValueY() : ピクセル単位の値YをScaleModeに従ってある単位の値Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueY()</para></remarks>
        public float RVY(float Value)
        {
            return GetReverseValueY(Value);
        }

        /// <summary>GetReverseValueArrayX() : ピクセル単位の値配列XをScaleModeに従ってある単位の値配列Xに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayX()</para></remarks>
        public float[] RVAX(float[] Value)
        {
            return GetReverseValueArrayX(Value);
        }

        /// <summary>GetReverseValueArrayY() : ピクセル単位の値配列YをScaleModeに従ってある単位の値配列Yに変換して返す</summary> 
        /// <param name="Value">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArrayY()</para></remarks>
        public float[] RVAY(float[] Value)
        {
            return GetReverseValueArrayY(Value);
        }

        /// <summary>GetReversePoint() : ピクセル単位での座標点をScaleModeに従ってある単位での座標点に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点</param> 
        /// <returns>変換後の単位での座標点</returns> 
        /// <remarks>内部アクセス名<para>GetReversePoint()</para></remarks>
        public PointF RP(PointF Value)
        {
            return GetReversePoint(Value);
        }

        /// <summary>GetReverseArrayPoint() : ピクセル単位での座標点配列をScaleModeに従ってある単位での座標点配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位の座標点配列</param> 
        /// <returns>変換後の単位での座標点配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseArrayPoint()</para></remarks>
        public PointF[] RAP(PointF[] Value)
        {
            return GetReverseArrayPoint(Value);
        }

        /// <summary>GetReverseValueSize() : ピクセル単位でのサイズをScaleModeに従ってある単位でのサイズに変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ</param> 
        /// <returns>変換後の単位でのサイズ</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueSize()</para></remarks>
        public SizeF RVS(SizeF Value)
        {
            return GetReverseValueSize(Value);
        }

        /// <summary>GetReverseValueArraySize() : ピクセル単位でのサイズ配列をScaleModeに従ってある単位でのサイズ配列に変換して返す</summary> 
        /// <param name="Value">ピクセル単位のサイズ配列</param> 
        /// <returns>変換後の単位でのサイズ配列</returns> 
        /// <remarks>内部アクセス名<para>GetReverseValueArraySize()</para></remarks>
        public SizeF[] RVAS(SizeF[] Value)
        {
            return GetReverseValueArraySize(Value);
        }
        #endregion

        #region その他の変換
        /// <summary>GetStepX() : 前の描画位置からの相対座標値Xを本来の座標値Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepX()</para></remarks>
        public float SX(float Value)
        {
            return GetStepX(Value);
        }

        /// <summary>GetStepY() : 前の描画位置からの相対座標値Yを本来の座標値Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        /// <remarks>内部アクセス名<para>GetStepY()</para></remarks>
        public float SY(float Value)
        {
            return GetStepY(Value);
        }

        /// <summary>GetStepArrayX() : 前の描画位置からの相対座標値配列Xを本来の座標値配列Xに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayX()</para></remarks>
        public float[] SAX(float[] Value)
        {
            return GetStepArrayX(Value);
        }

        /// <summary>GetStepArrayY() : 前の描画位置からの相対座標値配列Yを本来の座標値配列Yに変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayY()</para></remarks>
        public float[] SAY(float[] Value)
        {
            return GetStepArrayY(Value);
        }

        /// <summary>GetStepPoint() : 前の描画位置からの相対座標点を本来の座標点に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点</param>
        /// <returns>本来の座標点</returns>
        /// <remarks>内部アクセス名<para>GetStepPoint()</para></remarks>
        public PointF SP(PointF Value)
        {
            return GetStepPoint(Value);
        }

        /// <summary>GetStepArrayPoint() : 前の描画位置からの相対座標点配列を本来の座標点配列に変換して返す</summary>
        /// <param name="Value">前の描画位置からの相対座標点配列</param>
        /// <returns>本来の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetStepArrayPoint()</para></remarks>
        public PointF[] SAP(PointF[] Value)
        {
            return GetStepArrayPoint(Value);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public float[] PA(float[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public PointF[] PA(PointF[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="Length">配列の先頭からの抜き出したい要素数</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public SizeF[] PA(SizeF[] Value, int Length)
        {
            return GetPartialArray(Value, 0, Length - 1);
        }

        /// <summary>GetPartialArray() : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標値配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public float[] PA(float[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標点配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public PointF[] PA(PointF[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>GetPartialArray() : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        /// <remarks>内部アクセス名<para>GetPartialArray()</para></remarks>
        public SizeF[] PA(SizeF[] Value, int StartIndex, int EndIndex)
        {
            return GetPartialArray(Value, StartIndex, EndIndex);
        }
        #endregion

        #region メソッドの中身の記述

        #region 内部通常変換
        /// <summary>X : ScaleModeに従ってある単位での座標Xをピクセル単位での座標Xに変換して返す</summary> 
        /// <param name="X">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns>
        [EditorBrowsable(EBState)]
        public float GetX(float X)
        {
            return this.Target.GetX(X);
        }

        /// <summary>Y : ScaleModeに従ってある単位での座標Yをピクセル単位での座標Yに変換して返す</summary> 
        /// <param name="Y">変換前の単位での座標値</param> 
        /// <returns>ピクセル単位の座標値</returns> 
        [EditorBrowsable(EBState)]
        public float GetY(float Y)
        {
            return this.Target.GetY(Y);
        }

        /// <summary>AX : ScaleModeに従ってある単位での座標配列Xをピクセル単位での座標配列Xに変換して返す</summary> 
        /// <param name="X">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetArrayX(float[] X)
        {
            return this.Target.GetArrayX(X);
        }

        /// <summary>AY : ScaleModeに従ってある単位での座標配列Yをピクセル単位での座標配列Yに変換して返す</summary> 
        /// <param name="Y">変換前の単位での座標値配列</param> 
        /// <returns>ピクセル単位の座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetArrayY(float[] Y)
        {
            return this.Target.GetArrayY(Y);
        }

        /// <summary>VX : ScaleModeに従ってある単位の値Xをピクセル単位の値Xに変換して返す</summary> 
        /// <param name="VX">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        [EditorBrowsable(EBState)]
        public float GetValueX(float VX)
        {
            return this.Target.GetValueX(VX);
        }

        /// <summary>VY : ScaleModeに従ってある単位の値Yをピクセル単位の値Yに変換して返す</summary> 
        /// <param name="VY">変換前の単位での値</param> 
        /// <returns>ピクセル単位の値</returns> 
        [EditorBrowsable(EBState)]
        public float GetValueY(float VY)
        {
            return this.Target.GetValueY(VY);
        }

        /// <summary>VAX : ScaleModeに従ってある単位の値配列Xをピクセル単位の値配列Xに変換して返す</summary> 
        /// <param name="VX">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetValueArrayX(float[] VX)
        {
            return this.Target.GetValueArrayX(VX);
        }

        /// <summary>VAY : ScaleModeに従ってある単位の値配列Yをピクセル単位の値配列Yに変換して返す</summary> 
        /// <param name="VY">変換前の単位での値配列</param> 
        /// <returns>ピクセル単位の値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetValueArrayY(float[] VY)
        {
            return this.Target.GetValueArrayY(VY);
        }

        /// <summary>P : ScaleModeに従ってある単位の座標点をピクセル単位の座標点に変換して返す</summary>
        /// <param name="P">変換前の単位での座標点</param>
        /// <returns>ピクセル単位の座標点</returns>
        [EditorBrowsable(EBState)]
        public PointF GetPoint(PointF P)
        {
            return this.Target.GetPoint(P);
        }

        /// <summary>AP : GetArrayPoint() : ScaleModeに従ってある単位の座標点配列をピクセル単位の座標点配列に変換して返す</summary>
        /// <param name="P">変換前の単位での座標点配列</param>
        /// <returns>ピクセル単位の座標点配列</returns>
        [EditorBrowsable(EBState)]
        public PointF[] GetArrayPoint(PointF[] P)
        {
            return this.Target.GetArrayPoint(P);
        }

        /// <summary>VS : ScaleModeに従ってある単位のサイズをピクセル単位のサイズに変換して返す</summary> 
        /// <param name="S">変換前の単位でのサイズ</param> 
        /// <returns>ピクセル単位のサイズ</returns> 
        [EditorBrowsable(EBState)]
        public SizeF GetValueSize(SizeF S)
        {
            return this.Target.GetValueSize(S);
        }

        /// <summary>VAS : ScaleModeに従ってある単位のサイズ配列をピクセル単位のサイズ配列に変換して返す</summary> 
        /// <param name="S">変換前の単位でのサイズ配列</param> 
        /// <returns>ピクセル単位のサイズ配列</returns> 
        [EditorBrowsable(EBState)]
        public SizeF[] GetValueArraySize(SizeF[] S)
        {
            return this.Target.GetValueArraySize(S);
        }
        #endregion

        #region 内部逆変換
        /// <summary>RX : ピクセル単位での座標XをScaleModeに従ってある単位での座標Xに変換して返す</summary> 
        /// <param name="X">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        [EditorBrowsable(EBState)]
        public float GetReverseX(float X)
        {
            return this.Target.GetReverseX(X);
        }

        /// <summary>RY : ピクセル単位での座標YをScaleModeに従ってある単位での座標Yに変換して返す</summary> 
        /// <param name="Y">ピクセル単位の座標値</param> 
        /// <returns>変換後の単位での座標値</returns> 
        [EditorBrowsable(EBState)]
        public float GetReverseY(float Y)
        {
            return this.Target.GetReverseY(Y);
        }

        /// <summary>RAX : ピクセル単位での座標配列XをScaleModeに従ってある単位での座標配列Xに変換して返す</summary> 
        /// <param name="X">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetReverseArrayX(float[] X)
        {
            return this.Target.GetReverseArrayX(X);
        }

        /// <summary>RAY : ピクセル単位での座標配列YをScaleModeに従ってある単位での座標配列Yに変換して返す</summary> 
        /// <param name="Y">ピクセル単位の座標値配列</param> 
        /// <returns>変換後の単位での座標値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetReverseArrayY(float[] Y)
        {
            return this.Target.GetReverseArrayY(Y);
        }

        /// <summary>RVX : ピクセル単位の値XをScaleModeに従ってある単位の値Xに変換して返す</summary> 
        /// <param name="VX">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        [EditorBrowsable(EBState)]
        public float GetReverseValueX(float VX)
        {
            return this.Target.GetReverseValueX(VX);
        }

        /// <summary>RVY : ピクセル単位の値YをScaleModeに従ってある単位の値Yに変換して返す</summary> 
        /// <param name="VY">ピクセル単位の値</param> 
        /// <returns>変換後の単位での値</returns> 
        [EditorBrowsable(EBState)]
        public float GetReverseValueY(float VY)
        {
            return this.Target.GetReverseValueY(VY);
        }

        /// <summary>RVAX : ピクセル単位の値配列XをScaleModeに従ってある単位の値配列Xに変換して返す</summary> 
        /// <param name="VX">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetReverseValueArrayX(float[] VX)
        {
            return this.Target.GetReverseValueArrayX(VX);
        }

        /// <summary>RVAY : ピクセル単位の値配列YをScaleModeに従ってある単位の値配列Yに変換して返す</summary> 
        /// <param name="VY">ピクセル単位の値配列</param> 
        /// <returns>変換後の単位での値配列</returns> 
        [EditorBrowsable(EBState)]
        public float[] GetReverseValueArrayY(float[] VY)
        {
            return this.Target.GetReverseValueArrayY(VY);
        }

        /// <summary>RP : ピクセル単位での座標点をScaleModeに従ってある単位での座標点に変換して返す</summary> 
        /// <param name="P">ピクセル単位の座標点</param> 
        /// <returns>変換後の単位での座標点</returns> 
        [EditorBrowsable(EBState)]
        public PointF GetReversePoint(PointF P)
        {
            return this.Target.GetReversePoint(P);
        }

        /// <summary>RAP : ピクセル単位での座標点配列をScaleModeに従ってある単位での座標点配列に変換して返す</summary> 
        /// <param name="P">ピクセル単位の座標点配列</param> 
        /// <returns>変換後の単位での座標点配列</returns> 
        [EditorBrowsable(EBState)]
        public PointF[] GetReverseArrayPoint(PointF[] P)
        {
            return this.Target.GetReverseArrayPoint(P);
        }

        /// <summary>RVS : ピクセル単位でのサイズをScaleModeに従ってある単位でのサイズに変換して返す</summary> 
        /// <param name="S">ピクセル単位のサイズ</param> 
        /// <returns>変換後の単位でのサイズ</returns> 
        [EditorBrowsable(EBState)]
        public SizeF GetReverseValueSize(SizeF S)
        {
            return this.Target.GetReverseValueSize(S);
        }

        /// <summary>RVAS : ピクセル単位でのサイズ配列をScaleModeに従ってある単位でのサイズ配列に変換して返す</summary> 
        /// <param name="S">ピクセル単位のサイズ配列</param> 
        /// <returns>変換後の単位でのサイズ配列</returns> 
        [EditorBrowsable(EBState)]
        public SizeF[] GetReverseValueArraySize(SizeF[] S)
        {
            return this.Target.GetReverseValueArraySize(S);
        }
        #endregion

        #region 内部その他の変換
        /// <summary>SX : 前の描画位置からの相対座標値Xを本来の座標値Xに変換して返す</summary>
        /// <param name="X">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        [EditorBrowsable(EBState)]
        public float GetStepX(float X)
        {
            return this.Target.GetStepX(X);
        }

        /// <summary>SY : 前の描画位置からの相対座標値Yを本来の座標値Yに変換して返す</summary>
        /// <param name="Y">前の描画位置からの相対座標値</param>
        /// <returns>本来の座標値</returns>
        [EditorBrowsable(EBState)]
        public float GetStepY(float Y)
        {
            return this.Target.GetStepY(Y);
        }

        /// <summary>SAX : 前の描画位置からの相対座標値配列Xを本来の座標値配列Xに変換して返す</summary>
        /// <param name="X">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        [EditorBrowsable(EBState)]
        public float[] GetStepArrayX(float[] X)
        {
            return this.Target.GetStepArrayX(X);
        }

        /// <summary>SAY : 前の描画位置からの相対座標値配列Yを本来の座標値配列Yに変換して返す</summary>
        /// <param name="Y">前の描画位置からの相対座標値配列</param>
        /// <returns>本来の座標値配列</returns>
        [EditorBrowsable(EBState)]
        public float[] GetStepArrayY(float[] Y)
        {
            return this.Target.GetStepArrayY(Y);
        }

        /// <summary>SP : 前の描画位置からの相対座標点を本来の座標点に変換して返す</summary>
        /// <param name="P">前の描画位置からの相対座標点</param>
        /// <returns>本来の座標点</returns>
        [EditorBrowsable(EBState)]
        public PointF GetStepPoint(PointF P)
        {
            return this.Target.GetStepPoint(P);
        }

        /// <summary>SAP : 前の描画位置からの相対座標点配列を本来の座標点配列に変換して返す</summary>
        /// <param name="P">前の描画位置からの相対座標点配列</param>
        /// <returns>本来の座標点配列</returns>
        [EditorBrowsable(EBState)]
        public PointF[] GetStepArrayPoint(PointF[] P)
        {
            return this.Target.GetStepArrayPoint(P);
        }

        /// <summary>PA : ある座標値配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標値配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標値配列</returns>
        [EditorBrowsable(EBState)]
        public float[] GetPartialArray(float[] Value, int StartIndex, int EndIndex)
        {
            return this.Target.GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>PA : ある座標点配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となる座標点配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後の座標点配列</returns>
        [EditorBrowsable(EBState)]
        public PointF[] GetPartialArray(PointF[] Value, int StartIndex, int EndIndex)
        {
            return this.Target.GetPartialArray(Value, StartIndex, EndIndex);
        }

        /// <summary>PA : あるサイズ配列から指定した範囲だけを抜き出して返す</summary>
        /// <param name="Value">基となるサイズ配列</param>
        /// <param name="StartIndex">配列の先頭からの抜き出したい最初の要素番号</param>
        /// <param name="EndIndex">配列の先頭からの抜き出したい最後の要素番号</param>
        /// <returns>抜き出した後のサイズ配列</returns>
        [EditorBrowsable(EBState)]
        public SizeF[] GetPartialArray(SizeF[] Value, int StartIndex, int EndIndex)
        {
            return this.Target.GetPartialArray(Value, StartIndex, EndIndex);
        }
        #endregion

        #endregion

        #endregion
    }
    #endregion
}
